maxVector.cljs

(def points [{:x 1, :y 1} {:x -1, :y 1} {:x -1, :y -1} {:x 1, :y -1} {:x 2, :y 2} {:x -1, :y 2} {:x -1, :y -2} {:x 1, :y -2} {:x 1, :y 6} {:x -1, :y 4} {:x -3, :y -1} {:x 1, :y -1} {:x 10, :y 1} {:x -1, :y 11} {:x -1, :y -1} {:x 1, :y -1}])

(defn samePolarity? [a b] (if (or (and (< a 0) (< b 0)) (and (>= a 0) (>= b 0))) true false))

(defn square-magnitude [a b] (+ (* a a) (* b b)))

(defn
 largestVectorInQuadrant
 [points x y]
 (->>
  points
  (filter (fn [pt] (and (samePolarity? (get pt :x) x) (samePolarity? (get pt :y) y))))
  (map (fn [pt] (conj pt [:magnitude (square-magnitude (get pt :x) (get pt :y))])))
  (reduce (fn [maxPt pt] (if (> (get maxPt :magnitude) (get pt :magnitude)) maxPt pt)))))

(def largestVector (largestVectorInQuadrant points 1 1))

(println largestVector)

maxVector.js

var points = [{x: 1, y: 1 }, {x: -1, y: 1 }, {x: -1, y: -1 }, {x: 1, y: -1 }, {x: 2, y: 2 }, {x: -1, y: 2 }, {x: -1, y: -2 }, {x: 1, y: -2 }, {x: 1, y: 6 }, {x: -1, y: 4 }, {x: -3, y: -1 }, {x: 1, y: -1 }, {x: 10, y: 1 }, {x: -1, y: 11 }, {x: -1, y: -1 }, {x: 1, y: -1 } ]

function getLargestVectorInQuadrant(points, x, y) {

	function isSamePolarity( a, b ) {
		if(( a < 0 && b < 0 ) || ( a >=0 && b >=0 )) return true;
		else return false;
	}

	function magnitudeSquared( a, b ) {
		return ( a*a + b*b )
	}

	var largestVector = points
		.filter( function ( point ) {
			return isSamePolarity( point.x, x ) && isSamePolarity( point.y, y );
		})
		.map( function ( point ) {
			return {
				x: point.x,
				y: point.y,
				magnitude: magnitudeSquared( point.x, point.y )
			}
		})
		.reduce( function ( maxPoint, point ) {
			return maxPoint.magnitude > point.magnitude ? maxPoint : point
		}, { magnitude: -Infinity } );

	return largestVector;
}

var quadrant = {x: -1, y: 1};
var largestVector = getLargestVectorInQuadrant (points, quadrant.x, quadrant.y);
var resultString = [ 
	'Largest vector in Quadrant : ',
	'(', quadrant.x, ',' ,quadrant.y, ') is ',
	'(', largestVector.x, ',', largestVector.y, ')',
	'with a magnitude of:', Math.sqrt(largestVector.magnitude)
].join(' ');
console.log( resultString );

ES6+ version:

const isSamePolarity = (a, b) => (a < 0 && b < 0) || (a >=0 && b >=0);

const magnitudeSquared = (a, b) => (a * a) + (b * b);

const getLargestVectorInQuadrant = (points, x, y) => points
    .filter( point => isSamePolarity(point.x, x) && isSamePolarity(point.y, y) )
    .map( point => ({ ...point, magnitude: magnitudeSquared(point.x, point.y) }) )
    .reduce( 
        (maxPoint, point) => maxPoint.magnitude > point.magnitude ? maxPoint : point,
        { magnitude: -Infinity }
    );