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 <math.h>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <cstdio>
#include <string.h>
using namespace std;

#define FOR(i, n) for(int i = 0; i < n; i++)
#define bit(i) static_cast<bitset<8> >(i)

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> VI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long long, long long>PLL;
typedef queue<int> QI;
typedef priority_queue<int> maxpq;
typedef priority_queue<int, vector<int>, greater<int> > minpq;

struct edge{int to, cost;};

void begin(){cin.tie(0); ios::sync_with_stdio(false);};
int gcd(int a, int b){if(a%b==0){return(b);}else{return(gcd(b,a%b));}};
int lcm(int m, int n){if((0 == m)||(0 == n)){return 0;} return ((m / gcd(m, n)) * n);};
unsigned long long comb(long n, long m){unsigned long long c = 1; m = (n - m < m ? n - m : m);
    for(long ns = n - m + 1, ms = 1; ms <= m; ns ++, ms ++){c *= ns; c /= ms;} return c;};

// ワーシャルフロイド法
void warshallFloyd(int d[100][100], int n){
    for(int k = 0; k < n; ++k)
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < n; ++j)
                if(d[i][k] != -1 && d[k][j] != -1){
                    if(d[i][j] == -1){
                        d[i][j] = d[i][k] + d[k][j];
                    }else{
                        d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
                    }
                }
};


// d:隣接行列  n:グラフのサイズ  s:始点  dist:始点からの距離が入る配列
void dijkstra(int d[1000][1000], int n, int s, int dist[1000]){
    FOR(i, n) dist[i] = -1;
    dist[s] = 0;
    priority_queue<PII, vector<PII>, greater<PII> > q;
    q.push(PII(0, s));
    while (!q.empty()) {
        PII p = q.top(); q.pop();
        int i = p.second;
        if(dist[i] < p.first) continue;
        for(int j = 0; j < n; j++){
            if(d[i][j] == -1) continue;
            if(dist[j] == -1){
                dist[j] = dist[i] + d[i][j];
                q.push(PII(dist[j], j));
            }else if(dist[j] > dist[i] + d[i][j]){
                dist[j] = dist[i] + d[i][j];
                q.push(PII(dist[j], j));
            }
        }
    }
};

// 線分の交差判定
bool isCross(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4){
    // 並行な場合
    int m = (x2-x1)*(y4-y3)-(y2-y1)*(x4-x3);
    if(m == 0) return false;
    // 媒介変数の値が0より大きく1以下なら交差する、これは問題の状況によって変わるかも。
    double r =(double)((y4-y3)*(x3-x1)-(x4-x3)*(y3-y1))/m;
    double s =(double)((y2-y1)*(x3-x1)-(x2-x1)*(y3-y1))/m;
    return (0 < r && r <= 1 && 0 < s && s <= 1);
};

// 外積の計算 AB CD
int crossProdct(int ax, int ay, int bx, int by, int cx, int cy, int dx, int dy){
    int abx = bx - ax;
    int aby = by - ay;
    int cdx = cx - dx;
    int cdy = cy - dy;
    return abx * cdy - cdx - aby;
};

double crossProdct(double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy){
    double abx = bx - ax;
    double aby = by - ay;
    double cdx = cx - dx;
    double cdy = cy - dy;
    return abx * cdy - cdx - aby;
};

// 三角形の内部判定
bool inTriangle(int ax, int ay, int bx, int by, int cx, int cy, int px, int py){
    int abx = bx - ax;
    int aby = by - ay;
    int bcx = cx - bx;
    int bcy = cy - by;
    int cax = ax - cx;
    int cay = ay - cy;
    
    int apx = px - ax;
    int apy = py - ay;
    int bpx = px - bx;
    int bpy = py - by;
    int cpx = px - cx;
    int cpy = py - cy;
    
    int c1 = abx * bpy - aby * bpx;
    int c2 = bcx * cpy - bcy * cpx;
    int c3 = cax * apy - cay * apx;
    return (c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0);
};

bool inTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py){
    double c1 = crossProdct(ax, ay, bx, by, bx, by, px, py);
    double c2 = crossProdct(bx, by, cx, cy, cx, cy, px, py);
    double c3 = crossProdct(cx, cy, ax, ay, ax, ay, px, py);
    return (c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0);
};

void cp(int a1[], int a2[], int l){FOR(i, l) a2[i] = a1[i];};



/**
 * start
 * @author yoshikyoto
 */
int main(int argc, const char * argv[]){
    begin();
    double ax, ay, bx, by, cx, cy, px, py;
    while(cin >> ax >> ay >> bx >> by >> cx >> cy >> px >> py){
        if(inTriangle(ax, ay, bx, by, cx, cy, px, py)){
            cout << "YES" << endl;
        }else{
            cout << "NO" << endl;
        }
    }
}

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

using namespace std;

struct Vector
{
public:
	double x;
	double y;

public:
	inline Vector()
	{

	}
	
	inline Vector(const int& x, const int& y) :
		x(x),
		y(y)
	{

	}
};

istream& operator>>(std::istream& stream, Vector& vector)
{
	stream >> vector.x >> vector.y;
	return stream;
}

struct Segment
{
public:
	Vector begin;
	Vector end;

public:
	inline Segment(const Vector& begin, const Vector& end) :
		begin(begin.x, begin.y),
		end  (end  .x, end  .y)
	{

	}
};

bool isLeft(Segment segment, Vector point)
{
	return (segment.end.x - segment.begin.x)*(point.y - segment.begin.y) - (segment.end.y - segment.begin.y) * (point.x - segment.begin.x) > -0.0001;
}

int main()
{
	Vector A, B, C, P;
	while(cin >> A >> B >> C >> P)
	{
		if( isLeft(Segment(A, B), P) && isLeft(Segment(B, C), P) && isLeft(Segment(C, A), P) )
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}

	return 0;
}

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

double length( double x1, double y1, double x2, double y2 )
{
    return sqrt( pow(x2-x1,2) + pow(y2-y1,2) );
}

double Surface_Area( double a, double b, double c )
{
    double sin, cos;
    cos = ( a * a - b * b - c * c ) / ( -2 * b * c );
    sin = sqrt( 1 - cos*cos );
    return 0.5 * c * b * sin;
}

int main() 
{
    double x1,y1,x2,y2,x3,y3,xp,yp;

    //a(x1,y1) b(x2,y2) c(x3,y3) p(xp,yp)
    while( cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp )
    {
        double ab = length( x1, y1, x2, y2 ), bc = length( x2, y2, x3, y3 ), ca = length( x1, y1, x3, y3 );
        double ap = length( x1, y1, xp, yp ), bp = length( x2, y2, xp, yp ), cp = length( x3, y3, xp, yp );

        double s1, s2, s3, s4;
        s1 = Surface_Area( bc, ca, ab );
        s2 = Surface_Area( cp, ca, ap );
        s3 = Surface_Area( bp, cp, bc );
        s4 = Surface_Area( ap, ab, bp );

        if( fabs( s1 - ( s2 + s3 + s4 ) ) < 0.0000001 )         //fabsは絶対値を返す関数
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }
}

C++: import sys
def side(p1, p2, p3): return (p3[1]-p1[1])*(p2[0]-p1[0])-(p2[1]-p1[1])*(p3[0]-p1[0])>0
 
for s in sys.stdin:
  x = map(float, raw_input().split())
  p1 = x[0:2]
  p2 = x[2:4]
  p3 = x[4:6]
  p0 = x[6:]
  print ["NO","YES"][(side(p1, p2, p0)==side(p2, p3, p0) and side(p2, p3, p0)==side(p3, p1, p0))]