Tasks Details
medium
Given a set of points on a plane, find the largest number of points that can be enclosed within a circle centered on the origin, such that the number of red points and green points inside it is equal.
Task Score
61%
Correctness
100%
Performance
9%
There are N points (numbered from 0 to N−1) on a plane. Each point is colored either red ('R') or green ('G'). The K-th point is located at coordinates (X[K], Y[K]) and its color is colors[K]. No point lies on coordinates (0, 0).
We want to draw a circle centered on coordinates (0, 0), such that the number of red points and green points inside the circle is equal. What is the maximum number of points that can lie inside such a circle? Note that it is always possible to draw a circle with no points inside.
Write a function:
class Solution { public int solution(int[] X, int[] Y, string colors); }
that, given two arrays of integers X, Y and a string colors, returns an integer specifying the maximum number of points inside a circle containing an equal number of red points and green points.
Examples:
1. Given X = [4, 0, 2, −2], Y = [4, 1, 2, −3] and colors = "RGRR", your function should return 2. The circle contains points (0, 1) and (2, 2), but not points (−2, −3) and (4, 4).
2. Given X = [1, 1, −1, −1], Y = [1, −1, 1, −1] and colors = "RGRG", your function should return 4. All points lie inside the circle.
3. Given X = [1, 0, 0], Y = [0, 1, −1] and colors = "GGR", your function should return 0. Any circle that contains more than zero points has an unequal number of green and red points.
4. Given X = [5, −5, 5], Y = [1, −1, −3] and colors = "GRG", your function should return 2.
5. Given X = [3000, −3000, 4100, −4100, −3000], Y = [5000, −5000, 4100, −4100, 5000] and colors = "RRGRG", your function should return 2.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays X and Y is an integer within the range [−20,000..20,000];
- string colors is made only of the characters 'R' and/or 'G';
- no point lies on the coordinates (0, 0).
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used C#
Time spent on task 11 minutes
Notes
not defined yet
Code: 16:49:30 UTC,
java,
autosave
Code: 16:49:41 UTC,
cs,
autosave
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
Code: 16:49:52 UTC,
cs,
autosave
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
Code: 16:50:22 UTC,
cs,
autosave
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
using nam
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
Code: 16:50:53 UTC,
cs,
autosave
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
}
Code: 16:51:16 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:51:42 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
}
Code: 16:51:52 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:52:11 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistancesdistances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:52:28 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistancesdistances);
List<Circle> circles = createCirclesWithPo(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:52:38 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistancesdistances);
List<Circle> circles = createCirclesWithPo(uniqueDistances;
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:52:53 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:53:07 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistance(distances)
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:53:32 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:54:02 UTC,
cs,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:54:12 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:54:47 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:55:06 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:55:25 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194
using System;
using System.Collections.Generic;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:55:55 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:57:31 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
ng System.
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:57:37 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:58:02 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f=
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:58:24 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
f.
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:58:38 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:58:49 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:59:18 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge{
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Analysis
Compile error
Compilation failed: 1 error(s), 0 warnings exec.cs(18,5): error CS0246: The type or namespace name `Solution' could not be found. Are you missing `challenge' using directive?
Code: 16:59:45 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
namespace challenge
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:59:55 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
}
Code: 16:59:58 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
Code: 17:00:02 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
Code: 17:00:15 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
Code: 17:00:18 UTC,
cs,
final,
score:
61
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[] X, int[] Y, string colors) {
var f= new Finder(X,Y,colors);
return f.findEvenPointsCircle();
}
}
internal class Circle
{
private Point point;
private double radius;
private List<Point> pointsInsideThisCircle =new List<Point>();
private int numberOfGreenPoints;
private int numberOfRedPoints;
public Circle(Point point)
{
this.point = point;
}
public Double calculateRadiusFormOrgin()
{
radius= Math.Sqrt((point.x * point.x) + (point.y * point.y));
return radius;
}
//point checker
private bool checkPointInsideCircle(Point point)
{
return point.DistanceFromOrigin <= radius;
}
public List<Point> pointsInsideCircle(List<Point> points)
{
foreach(Point point in points)
{
if (checkPointInsideCircle(point))
{
pointsInsideThisCircle.Add(point);
}
}
return pointsInsideThisCircle;
}
public int countGreenPoints()
{
int count = 0;
foreach(Point p in pointsInsideThisCircle)
{
if (p.Color == 'G')
{
count++;
}
}
numberOfGreenPoints = count;
return count;
}
public int countRedPoints()
{
int count= 0;
foreach(Point p in pointsInsideThisCircle)
{
if(p.Color == 'R')
{
count++;
}
}
numberOfRedPoints = count;
return count;
}
public bool checkForEvenNumberOfRedAndGreenPoints()
{
return numberOfRedPoints == numberOfGreenPoints;
}
public int numberOfPointsInside()
{
return pointsInsideThisCircle.Count;
}
}
internal class Point
{
public int x;
public int y;
private char color;
public double distanceFromOrigin;
public Point(int x,int y,char color)
{
this.x = x;
this.y = y;
this.color = color;
}
public char Color
{
get { return color; }
}
public double DistanceFromOrigin
{
get {
distanceFromOrigin = calculateRadiusFormOrgin(x, y);
return distanceFromOrigin;
}
}
private Double calculateRadiusFormOrgin(int x, int y)
{
distanceFromOrigin = Math.Sqrt((x * x) + (y * y));
return distanceFromOrigin;
}
}
internal class Finder
{
public List<Point> Points = new List<Point>();// { get; set; }
public int minDistanceFromOrigin = 0;
List<double> distances = new List<double>();
public Finder(int[] x,int[] y,string colors)
{
char[] c = colors.ToCharArray();
for(int i = 0; i < x.Length; i++)
{
Points.Add(new Point(x[i], y[i], c[i]));
}
}
public int findEvenPointsCircle()
{
int res = 0;
allPointsDistances();
List<double> uniqueDistances = findUnqueDistances(distances);
List<Circle> circles = createCirclesWithPoints(uniqueDistances);
foreach (Circle c in circles)
{
if (c.checkForEvenNumberOfRedAndGreenPoints())
{
res= c.numberOfPointsInside();
}
}
return res;
}
public List<Circle> createCirclesWithPoints(List<double> uniqueDistances)
{
List<Circle> circles = new List<Circle>();
foreach (double dis in uniqueDistances)
{
Point ps = Points.Find(p => p.distanceFromOrigin == dis);
Circle c = new Circle(ps);
c.calculateRadiusFormOrgin();
c.pointsInsideCircle(Points);
c.countGreenPoints();
c.countRedPoints();
circles.Add(c);
}
return circles;
}
private List<double> findUnqueDistances(List<double> DistancesTemp)
{
double d = 0;
//list<double> dis=distances.OrderByDescending(d).ThenBy(d => d).ToList();
DistancesTemp.Sort();
List<double> unqueDistances= new List<double> ();
foreach (double distance in DistancesTemp)
{
if (distance != d)
unqueDistances.Add(distance);
d = distance;
}
return unqueDistances;
}
public double findMinDistances(List<double> distances)
{
return distances.Min();
}
private void allPointsDistances()
{
foreach (Point point in Points)
{
distances.Add(point.DistanceFromOrigin);
}
}
}
Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N**2)
expand all
Correctness tests
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
6.
0.024 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
small_different_distances
Small tests where all points have distinct distances from the origin. N <= 50.
Small tests where all points have distinct distances from the origin. N <= 50.
✔
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.028 s
OK
5.
0.024 s
OK
small_imbalanced
Small tests where the proportion of color occurences is imbalanced. N <= 50.
Small tests where the proportion of color occurences is imbalanced. N <= 50.
✔
OK
1.
0.028 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.028 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
small_sorted
Small tests where points are given in increasing order of distance from (0, 0). N <= 50.
Small tests where points are given in increasing order of distance from (0, 0). N <= 50.
✔
OK
1.
0.024 s
OK
2.
0.028 s
OK
3.
0.028 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
6.
0.024 s
OK
7.
0.024 s
OK
8.
0.024 s
OK
expand all
Correctness/performance tests
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
6.
0.024 s
OK
7.
0.024 s
OK
8.
0.024 s
OK
expand all
Performance tests
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
big_different_distances
Big tests where all points have distinct distances from the origin.
Big tests where all points have distinct distances from the origin.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
big_imbalanced
Big tests where the proportion of color occurences is imbalanced.
Big tests where the proportion of color occurences is imbalanced.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
4.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
big_compact
Big tests where points are very close to the origin.
Big tests where points are very close to the origin.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
big_sorted
Big tests where points are given in increasing order of distance from (0, 0).
Big tests where points are given in increasing order of distance from (0, 0).
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
4.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.