Go: package main

import (
	"bufio"
	"os"
	"strings"
	"strconv"
	"fmt"
)

func check(x, y, x1, y1, x2, y2 float64) float64 {
	return (x2-x1)*y - (y2-y1)*x + x1*y2 - x2*y1
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	a := make([]float64, 8)
	for scanner.Scan() {
		info := strings.Split(scanner.Text(), ",")
		for j := 0; j < 8; j++ {
			a[j], _ = strconv.ParseFloat(info[j], 64)
		}
		if check(a[0], a[1], a[2],a[3], a[6], a[7])*check(a[4], a[5], a[2], a[3], a[6], a[7]) < 0 && check(a[6], a[7], a[0], a[1], a[4], a[5])*check(a[2],a[3], a[0], a[1], a[4], a[5]) < 0 {
			fmt.Println("YES")	
		} else {
			fmt.Println("NO")
		}
	}
}

Python: from __future__ import (division, absolute_import, print_function,
                        unicode_literals)
from sys import stdin
from collections import namedtuple
Point = namedtuple('Point', 'x y')

def make_test(p1, p2):
    if p1.x == p2.x:
        gradient = p1.x
        return lambda p: gradient > p.x
    gradient = (p1.y - p2.y) / (p1.x - p2.x)
    y_intercept = p1.y - gradient * p1.x
    return lambda p: gradient * p.x + y_intercept > p.y

for line in stdin:
    it = (float(s) for s in line.split(','))
    A, B, C, D = (Point(next(it), next(it)) for _ in xrange(4))

    f = make_test(A, C)
    g = make_test(B, D)
    if f(B) == f(D) or g(A) == g(C):
        print('NO')
    else:
        print('YES')

Python: import math

class Point():
    def __init__(self, x, y):
        self.x = x
        self.y = y

def Cp(p1, p2, p3):
    xa = p1.x-p2.x
    ya = p1.y-p2.y
    xb = p3.x-p2.x
    yb = p3.y-p2.y
    return xa*yb-ya*xb

def get_input():
    while True:
        try:
            yield ''.join(input())
        except EOFError:
            break

N = list(get_input())
for l in range(len(N)):

    x1,y1,x2,y2,x3,y3,x4,y4 = [float(i) for i in N[l].split(",")]

    p1 = Point(x1,y1)
    p2 = Point(x2,y2)
    p3 = Point(x3,y3)
    p4 = Point(x4,y4)

    cp1 = Cp(p1,p2,p3)
    cp2 = Cp(p2,p3,p4)
    cp3 = Cp(p3,p4,p1)
    cp4 = Cp(p4,p1,p2)

    if cp1 > 0 and cp2 > 0 and cp3 > 0 and cp4 > 0:
        print("YES")
    elif cp1 < 0 and cp2 < 0 and cp3 < 0 and cp4 < 0:
        print("YES")
    else:
        print("NO")

Python: def judge(p1,p2,p3,p4):
    t1 = (p1[0] - p3[0]) * (p2[1] - p1[1]) + (p1[1] - p3[1]) * (p1[0] - p2[0])
    t2 = (p1[0] - p3[0]) * (p4[1] - p1[1]) + (p1[1] - p3[1]) * (p1[0] - p4[0])
    t3 = (p2[0] - p4[0]) * (p1[1] - p2[1]) + (p2[1] - p4[1]) * (p2[0] - p1[0])
    t4 = (p2[0] - p4[0]) * (p3[1] - p2[1]) + (p2[1] - p4[1]) * (p2[0] - p3[0])
    return t1*t2<0 and t3*t4<0
while True:
	try:
		x1,y1,x2,y2,x3,y3,x4,y4=map(float, input().split(","))
		A=[x1,y1]
		B=[x2,y2]
		C=[x3,y3]
		D=[x4,y4]
		print(A,B,C,D)
		if judge(A,B,C,D)==True or judge(A,D,B,C)==True :
			print("YES")
		else:
			print("NO")
	except EOFError:
		break

Python: from decimal import Decimal
import sys
for l in sys.stdin:
  xa,ya,xb,yb,xc,yc,xd,yd=list(map(Decimal,l.split(",")))
  a=xd-xb
  b=yd-yb
  c=xa-xb
  d=ya-yb
  e=xc-xb
  f=yc-yb
  try:
    s=(a*f-b*e)/(c*f-d*e)
    t=(-a*d+b*c)/(c*f-d*e)
  except:
    print("NO")
  if s>=0 and t>=0 and s+t>=1:
    print("YES")
  else:
    print("NO")

Python: def distance(ax,ay,bx,by):
    return (ax-bx)**2+(ay-by)**2

def yogen(plist, st):
    a = distance(plist[st], plist[st+1], plist[st+2], plist[st+3])
    b = distance(plist[st+2], plist[st+3], plist[st+4], plist[st+5])
    c = distance(plist[st+4], plist[st+5], plist[st+6], plist[st+7])
    return a+b-c >= 0

while True:
    try:
        points = list(map(float, input().split(",")))
        points.extend(points)
        points.extend(points)
        if yogen(points, 0) and yogen(points, 2) and yogen(points, 4) and yogen(points, 6): print("YES")
        else: print("NO")

    except EOFError: break

Python: class Vector2:
    """
    A simple 2D vector class.
    @Author:whitestone0811(Vir_MeL0)
    """
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def __add__(self,other):
        return Vector2(self.x+other.x,self.y+other.y)
    def __sub__(self,other):
        return Vector2(self.x-other.x,self.y-other.y)
    def __mul__(self,other):
        if isinstance(other, Vector2):
            return self.x*other.x+self.y*other.y
        else:
            return Vector2(self.x*other,self.y*other)
    def __rmul__(self,other):
        if not isinstance(other,Vector2):
            return Vector2(self.x*other,self.y*other)
    def abs(self):
        return (self.x**2+self.y**2)**0.5
    def cos(self,other):
        return (self*other)/(self.abs()*other.abs())
    def __str__(self):
        return "[{0},{1}]".format(self.x,self.y)
    def __neg__(self):
        return Vector2(-self.x,-self.y)
#    
_in=input()
while _in!='':
    cors=[float(cor)for cor in _in.split(',')]
    vAB=Vector2(cors[2]-cors[0],cors[3]-cors[1])
    vBC=Vector2(cors[4]-cors[2],cors[5]-cors[3])
    vCD=Vector2(cors[6]-cors[4],cors[7]-cors[5])
    vDA=Vector2(cors[0]-cors[6],cors[1]-cors[7])
    cnv_a=True if(vAB-vDA)*(vAB+vBC)>0 else False
    cnv_b=True if(vBC-vAB)*(vBC+vCD)>0 else False
    cnv_c=True if(vCD-vBC)*(vCD+vDA)>0 else False
    cnv_d=True if(vDA-vCD)*(vDA+vAB)>0 else False
    print("YES" if cnv_a and cnv_b and cnv_c and cnv_d else "NO")
    _in=input()

Python: def gai(a,b,c,d):
    S = a*d - b*c
    return(S)
while True:
    try:
        x1,y1,x2,y2,x3,y3,xp,yp  = map(float,input().split(","))
        A1,A2,B1,B2,C1,C2,D1,D2 = x1,y1,x2,y2,x3,y3,xp,yp
        
        if gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) < 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) < 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) < 0:
            print("NO")
        elif gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) > 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) > 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) > 0:
            print("NO")
        else:
            x1,y1,x2,y2,x3,y3,xp,yp = A1,A2,B1,B2,D1,D2,C1,C2
            if gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) < 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) < 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) < 0:
                print("NO")
            elif gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) > 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) > 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) > 0:
                print("NO")
            else:
                x1,y1,x2,y2,x3,y3,xp,yp = A1,A2,D1,D2,C1,C2,B1,B2
                if gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) < 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) < 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) < 0:
                    print("NO")
                elif gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) > 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) > 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) > 0:
                    print("NO")
                else:
                    x1,y1,x2,y2,x3,y3,xp,yp = D1,D2,B1,B2,C1,C2,A1,A2
                    if gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) < 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) < 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) < 0:
                        print("NO")
                    elif gai(x1 - x2,y1 - y2,x1 - xp,y1 - yp) > 0 and gai(x2 - x3,y2 - y3,x2 - xp,y2 - yp) > 0 and gai(x3 - x1,y3 - y1,x3 - xp,y3 - yp) > 0:
                        print("NO")
                    else:
                        print("YES")

            
    except EOFError:
        break

Python: while True:
    try:
        x_a, y_a, x_b, y_b, x_c, y_c, x_d, y_d = map(float, input().split(","))
        ab = [x_b - x_a, y_b - y_a]
        bc = [x_c - x_b, y_c - y_b]
        cd = [x_d - x_c, y_d - y_c]
        da = [x_a - x_d, y_a - y_d]
        crs_a = -(ab[0]*da[1] - ab[1]*da[0])
        crs_b = -(bc[0]*ab[1] - bc[1]*ab[0])
        crs_c = -(cd[0]*bc[1] - cd[1]*bc[0])
        crs_d = -(da[0]*cd[1] - da[1]*cd[0])
        if crs_a*crs_b*crs_c*crs_d < 0:
            print("NO")
        else:
            print("YES")
    except:
        break