Tasks Details
hard
Check whether a given polygon in a 2D plane is convex; if not, return the index of a vertex that doesn't belong to the convex hull.
Task Score
100%
Correctness
100%
Performance
100%
An array A of points in a 2D plane is given. These points represent a polygon: every two consecutive points describe an edge of the polygon, and there is an edge connecting the last point and the first point in the array.
A set of points in a 2D plane, whose boundary is a straight line, is called a semiplane. More precisely, any set of the form {(x, y) : ax + by ≥ c} is a semiplane. The semiplane contains its boundary.
A polygon is convex if and only if, no line segment between two points on the boundary ever goes outside the polygon.
For example, the polygon consisting of vertices whose Cartesian coordinates are consecutively:
(-1, 3) (3, 1) (0, -1) (-2, 1)is convex.
The convex hull of a finite set of points in a 2D plane is the smallest convex polygon that contains all points in this set. For example, the convex hull of a set consisting of seven points whose Cartesian coordinates are:
(-1, 3) (1, 2) (3, 1) (1, 1) (0, -1) (-2, 1) (-1, 2)is a polygon that has five vertices. When traversed clockwise, its vertices are:
(-1, 3) (1, 2) (3, 1) (0, -1) (-2, 1)
If a polygon is concave (that is, it is not convex), it has a vertex which does not lie on its convex hull border. Your assignment is to find such a vertex.
Assume that the following declarations are given:
// Point2D obj is an Object with attributes // obj.x - type: int // obj.y - type: int
Write a function:
function solution(A);
that, given a non-empty array A consisting of N elements describing a polygon, returns −1 if the polygon is convex. Otherwise, the function should return the index of any point that doesn't belong to the convex hull border. Note that consecutive edges of the polygon may be collinear (that is, the polygon might have 180−degrees angles).
To access the coordinates of the K-th point (where 0 ≤ K < N), use the following syntax:
- A[K].x to access the x-coordinate,
- A[K].y to access the y-coordinate.
For example, given array A such that:
A[0].x = -1 A[0].y = 3 A[1].x = 1 A[1].y = 2 A[2].x = 3 A[2].y = 1 A[3].x = 0 A[3].y = -1 A[4].x = -2 A[4].y = 1the function should return −1, as explained in the example above.
However, given array A such that:
A[0].x = -1 A[0].y = 3 A[1].x = 1 A[1].y = 2 A[2].x = 1 A[2].y = 1 A[3].x = 3 A[3].y = 1 A[4].x = 0 A[4].y = -1 A[5].x = -2 A[5].y = 1 A[6].x = -1 A[6].y = 2the function should return either 2 or 6. These are the indices of the polygon lying strictly in its convex hull (that is, not on the convex hull border).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [3..10,000];
- the coordinates of each point in array A are integers within the range [−1,000,000,000..1,000,000,000];
- no two edges of the polygon A intersect, other than meeting at their endpoints;
- array A does not contain duplicate points.
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used JavaScript
Time spent on task 66 minutes
Notes
not defined yet
Code: 11:57:12 UTC,
java,
autosave
Code: 11:58:59 UTC,
js,
autosave
Code: 11:59:11 UTC,
js,
autosave
Code: 11:59:21 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x - P.x, y: Q.y - P.y}
}
Code: 11:59:33 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.x - Q.y - P.y}
}
Code: 11:59:43 UTC,
js,
autosave
Code: 11:59:54 UTC,
js,
autosave
Code: 12:00:11 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator =
}
Code: 12:00:22 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x
}
Code: 12:00:33 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x
}
Code: 12:00:48 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
}
Code: 12:01:00 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const
}
Code: 12:01:25 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x)
}
Code: 12:01:53 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x*v1.x + v1.y*v1.y)
}
Code: 12:02:13 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
}
Code: 12:02:30 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
}
Code: 12:02:51 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator /
}
Code: 12:03:11 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
}
Code: 12:03:21 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if
}
Code: 12:03:38 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if qoutient < -1) {
}
}
Code: 12:03:59 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
}
}
Code: 12:04:22 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient )
}
Code: 12:04:37 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
}
Code: 12:05:01 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
angle
}
Code: 12:05:22 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = math
}
Code: 12:05:52 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = ath
}
Code: 12:06:02 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math
}
Code: 12:06:32 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos()
}
Code: 12:06:48 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
}
Code: 12:07:18 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y )
}
}
Code: 12:07:28 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y >)
}
}
Code: 12:07:52 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
}
}
}
Code: 12:08:15 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return
}
}
}
}
Code: 12:08:30 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
}
}
}
}
Code: 12:08:47 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
}
}
}
}
Code: 12:09:08 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s'
}
}
}
}
Code: 12:09:18 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:09:29 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
}
}
}
Code: 12:09:39 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:09:49 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:09:59 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
}
}
Code: 12:10:29 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x
}
}
Code: 12:10:59 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R
}
}
Code: 12:11:20 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
}
}
Code: 12:11:32 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:11:51 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:12:09 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:12:24 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:12:34 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:12:44 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:12:47 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:13:55 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
le
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:14:08 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:14:38 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 0)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:14:55 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 0; i < A.length - 1)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:15:06 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:15:20 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:15:40 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A))
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:16:05 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:16:24 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:16:48 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], ))
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:17:01 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]))
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:17:14 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:17:27 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:36:05 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:36:18 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:36:39 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', angle}
} else if (R.x > Q.x) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:36:52 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', angle}
} else {
return {'s', angle}
}
} else {
if (R.x < Q.x) {
return {'r', angle}
} else if (R.x > Q.x) {
return {'l', angle}
} else {
return {'s', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {'l', angle}
} else if (value > constant) {
return {'r', angle}
} else {
return {'s', angle}
}
} else {
if (value < constant) {
return {'r', angle}
} else if (value > constant) {
return {'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:37:22 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', angle}
} else {
return {dir: 's', angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', angle}
} else if (R.x > Q.x) {
return {dir: 'l', angle}
} else {
return {dir: 's', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', angle}
} else if (value > constant) {
return {dir: 'r', angle}
} else {
return {dir: 's', angle}
}
} else {
if (value < constant) {
return {dir: 'r', angle}
} else if (value > constant) {
return {dir: 'l', angle}
} else {
return {'s', angle}
}
}
}
}
Code: 12:37:34 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', angle}
} else if (R.x > Q.x) {
return {dir: 'l', angle}
} else {
return {dir: 's', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', angle}
} else if (value > constant) {
return {dir: 'r', angle}
} else {
return {dir: 's', angle}
}
} else {
if (value < constant) {
return {dir: 'r', angle}
} else if (value > constant) {
return {dir: 'l', angle}
} else {
return {dir: 's', angle}
}
}
}
}
Code: 12:37:44 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', angle}
} else {
return {dir: 's', angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', angle}
} else if (value > constant) {
return {dir: 'r', angle}
} else {
return {dir: 's', angle}
}
} else {
if (value < constant) {
return {dir: 'r', angle}
} else if (value > constant) {
return {dir: 'l', angle}
} else {
return {dir: 's', angle}
}
}
}
}
Code: 12:37:58 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', angle}
}
} else {
if (value < constant) {
return {dir: 'r', angle}
} else if (value > constant) {
return {dir: 'l', angle}
} else {
return {dir: 's', angle}
}
}
}
}
Code: 12:38:15 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles =
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:38:25 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
let totalAngles = 0
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:38:36 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:38:46 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:38:56 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
totalAngles
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:39:44 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
totalAngles
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:40:12 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
totalAngles += angles[i-1].dir
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:40:31 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
totalAngles += angles[i-1].dir ===
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:40:42 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
totalAngles += angles[i-1].dir === 'r'
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:41:05 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
totalAngles += angles[i-1].dir === 'r' ? angles[i-1].ang :
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:41:35 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
if (angles[i - 1].dir === 'r')
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:41:46 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
if (angles[i - 1].dir === 'r') {
total
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:42:12 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]))
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:42:23 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:42:40 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:43:01 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:43:12 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:43:33 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.lenght - 2].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:43:43 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:43:56 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:44:17 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:44:47 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
if (total)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:45:13 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:45:31 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:46:01 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; )
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:46:15 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < A)
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:46:46 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < Angles.length; i++) {
if (Angles[i].dir === )
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:47:02 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < Angles.length; i++) {
if (Angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:47:06 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < Angles.length; i++) {
if (Angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
ReferenceError: Angles is not defined
at solution (solution.js:34:25)
at solutionWrapper (/tmp/exec.js:404:28)
at Promise.resolve.then (/tmp/exec.js:430:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
ReferenceError: Angles is not defined
at solution (solution.js:34:25)
at solutionWrapper (/tmp/exec.js:404:28)
at Promise.resolve.then (/tmp/exec.js:430:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
Code: 12:47:19 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (Angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:47:23 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:47:24 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Analysis
expand all
Example tests
1.
0.068 s
WRONG ANSWER,
Given polygon is convex, but got 2
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.068 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
Code: 12:47:53 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
con
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:48:05 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient);
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
Given polygon is convex, but got 2
stdout:
1.0382922284930458
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.072 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
stdout:
0.39479111969976133
Code: 12:48:59 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient)*;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:49:10 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient)*180/Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:49:10 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient)*180/Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Code: 12:49:16 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'r', ang: angle}
} else if (value > constant) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Analysis
expand all
Example tests
1.
0.072 s
WRONG ANSWER,
Given polygon is convex, but got 2
stdout:
59.489762593884464
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.076 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
stdout:
22.619864948040444
Code: 12:49:33 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
360
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.072 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
stdout:
360
Code: 12:50:04 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (v1.x > 0) {
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:50:15 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:50:18 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:50:19 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
360
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.076 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
stdout:
360
Code: 12:50:36 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Analysis
expand all
Example tests
1.
0.076 s
OK
stdout:
360
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.072 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
stdout:
360
Code: 12:50:54 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
cons
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:51:05 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.push(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Analysis
expand all
Example tests
1.
0.076 s
OK
stdout:
[ { dir: 's', ang: 0.0000012074182697257333 },
{ dir: 'r', ang: 119.74488129694224 },
{ dir: 'r', ang: 78.69006752597979 },
{ dir: 'r', ang: 71.56505117707799 },
{ dir: 'r', ang: 90 } ]
360
example2
second example test
second example test
✘
WRONG ANSWER
Got 1, but 1 is an index of vertex that belongs to convex hull
Got 1, but 1 is an index of vertex that belongs to convex hull
1.
0.076 s
WRONG ANSWER,
Got 1, but 1 is an index of vertex that belongs to convex hull
stdout:
[ { dir: 'r', ang: 63.43494882292201 },
{ dir: 'l', ang: 90 },
{ dir: 'r', ang: 146.30993247402023 },
{ dir: 'r', ang: 78.69006752597979 },
{ dir: 'r', ang: 90 },
{ dir: 'l', ang: 45.00000000000001 },
{ dir: 'r', ang: 116.56505117707799 } ]
360
Code: 12:54:45 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.u(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:54:50 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[angles.length - 1].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:55:04 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[angles.length - 1].ang;
} else if (angles[angles.length - 1].dir === 'l') {
totalAngles -= angles[angles.length - 1].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:55:16 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Analysis
expand all
Example tests
1.
0.076 s
OK
stdout:
[ { dir: 'r', ang: 90 },
{ dir: 's', ang: 0.0000012074182697257333 },
{ dir: 'r', ang: 119.74488129694224 },
{ dir: 'r', ang: 78.69006752597979 },
{ dir: 'r', ang: 71.56505117707799 } ]
367.1250163489018
1.
0.076 s
OK
stdout:
[ { dir: 'r', ang: 116.56505117707799 },
{ dir: 'r', ang: 63.43494882292201 },
{ dir: 'l', ang: 90 },
{ dir: 'r', ang: 146.30993247402023 },
{ dir: 'r', ang: 78.69006752597979 },
{ dir: 'r', ang: 90 },
{ dir: 'l', ang: 45.00000000000001 } ]
495
Code: 12:58:47 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:59:07 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:59:21 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 12:59:51 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 13:00:14 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 13:00:27 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 13:00:47 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 13:00:54 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
console.log(angles)
console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
User test case 1:
[(2, 2), (0, 1), (-2, 2), (-1, 0), (-2, -2), (0, -1), (2, -2), (1, 0)]
Analysis
expand all
Example tests
1.
0.076 s
OK
stdout:
[ { dir: 'r', ang: 90 },
{ dir: 's', ang: 0.0000012074182697257333 },
{ dir: 'r', ang: 119.74488129694224 },
{ dir: 'r', ang: 78.69006752597979 },
{ dir: 'r', ang: 71.56505117707799 } ]
367.1250163489018
1.
0.076 s
OK
stdout:
[ { dir: 'r', ang: 116.56505117707799 },
{ dir: 'r', ang: 63.43494882292201 },
{ dir: 'l', ang: 90 },
{ dir: 'r', ang: 146.30993247402023 },
{ dir: 'r', ang: 78.69006752597979 },
{ dir: 'r', ang: 90 },
{ dir: 'l', ang: 45.00000000000001 } ]
495
expand all
User tests
1.
0.076 s
OK
function result: 1
function result: 1
stdout:
[ { dir: 'l', ang: 143.13010235415598 },
{ dir: 'r', ang: 53.130102354155994 },
{ dir: 'l', ang: 143.13010235415598 },
{ dir: 'r', ang: 53.130102354155994 },
{ dir: 'l', ang: 143.13010235415598 },
{ dir: 'r', ang: 53.130102354155994 },
{ dir: 'l', ang: 143.13010235415598 },
{ dir: 'r', ang: 53.130102354155994 } ]
-556.2602047083119
Code: 13:02:27 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
// console.log(angles)
// console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
Code: 13:02:30 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
// console.log(angles)
// console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
User test case 1:
[(2, 2), (0, 1), (-2, 2), (-1, 0), (-2, -2), (0, -1), (2, -2), (1, 0)]
Analysis
Code: 13:02:44 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
// console.log(angles)
// console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}
User test case 1:
[(2, 2), (0, 1), (-2, 2), (-1, 0), (-2, -2), (0, -1), (2, -2), (1, 0)]
Analysis
Code: 13:02:47 UTC,
js,
final,
score:
100
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
let angles = [];
let totalAngles = 0
for (let i = 1; i < A.length - 1; i++) {
angles.push(turn(A[i-1], A[i], A[i+1]));
if (angles[i - 1].dir === 'r') {
totalAngles += angles[i - 1].ang;
} else if (angles[i - 1].dir === 'l') {
totalAngles -= angles[i - 1].ang;
}
}
angles.push(turn(A[A.length-2], A[A.length-1], A[0]));
angles.unshift(turn(A[A.length-1], A[0], A[1]));
if (angles[angles.length - 2].dir === 'r') {
totalAngles += angles[angles.length - 2].ang;
} else if (angles[angles.length - 2].dir === 'l') {
totalAngles -= angles[angles.length - 2].ang;
}
if (angles[0].dir === 'r') {
totalAngles += angles[0].ang;
} else if (angles[0].dir === 'l') {
totalAngles -= angles[0].ang;
}
// console.log(angles)
// console.log(totalAngles);
let exterior = 'l';
if (totalAngles < 0) {
exterior = 'r';
}
for (let i = 0; i < angles.length; i++) {
if (angles[i].dir === exterior) {
return i;
}
}
return -1;
}
function turn(P, Q, R) {
const v1 = {x: Q.x - P.x, y: Q.y - P.y};
const v2 = {x: R.x - Q.x, y: R.y - Q.y};
const numerator = v1.x * v2.x + v1.y * v2.y;
const lenv1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
const lenv2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
let quotient = numerator / (lenv1 * lenv2);
if (quotient < -1) {
quotient = -1;
} else if (quotient > 1) {
quotient = 1
}
const angle = Math.acos(quotient) * 180 / Math.PI;
if (v1.x === 0) {
if (v1.y > 0) {
if (R.x < Q.x) {
return {dir: 'l', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
} else {
if (R.x < Q.x) {
return {dir: 'r', ang: angle}
} else if (R.x > Q.x) {
return {dir: 'l', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
} else {
const constant = v1.y * P.x - v1.x * P.y;
const value = v1.y * R.x - v1.x * R.y;
if (value < constant) {
return {dir: 'l', ang: angle}
} else if (value > constant) {
return {dir: 'r', ang: angle}
} else {
return {dir: 's', ang: angle}
}
}
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N)
expand all
Correctness tests
1.
0.068 s
OK
2.
0.068 s
OK
3.
0.068 s
OK
1.
0.068 s
OK
1.
0.068 s
OK
2.
0.068 s
OK
1.
0.068 s
OK
2.
0.068 s
OK
1.
0.068 s
OK
2.
0.076 s
OK
3.
0.068 s
OK
1.
0.068 s
OK
2.
0.068 s
OK
3.
0.068 s
OK
4.
0.068 s
OK
5.
0.068 s
OK
6.
0.068 s
OK
7.
0.068 s
OK
8.
0.072 s
OK
9.
0.068 s
OK
10.
0.068 s
OK
11.
0.068 s
OK
12.
0.068 s
OK
1.
0.068 s
OK
2.
0.068 s
OK
3.
0.068 s
OK
4.
0.068 s
OK
5.
0.068 s
OK
6.
0.068 s
OK
1.
0.068 s
OK
1.
0.108 s
OK