So i am making a function that scans a Grid and every square's neighbours, and changes certain values (dead/live) in the grid. The current problem I have is: The modifications are made to certain parts of the grid BEFORE the whole scan is done. This means the scan will come out wrong. Here is the code to the function:
public void GridScan(Vector3 worldposition, int range)
{
GetXY(worldposition, out int originx, out int originy);
for (int x = 0; x < range; x++)
{
for (int y = 0; y < range; y++)
{
Debug.Log(GetValue(originx + x, originy + y));
if ((GetValue(originx + x, originy + y)) == 100)
{
if (Neighbours(GetWorldPosition(x, y), 2) < 2)
{
SetValue(x, y, 0);
}
if (Neighbours(GetWorldPosition(x, y), 2) > 3)
{
SetValue(x, y, 0);
}
}
if ((GetValue(originx + x, originy + y)) == 0)
{
if (Neighbours(GetWorldPosition(x, y), 2) == 3)
{
SetValue(x, y, 100);
}
}
}
}
}
Bit of context:
"GetXY" simply converts the vector3 worldposition to coordinates of the graph.
The two for loops scan through the whole graph from the origin, going from (0,0)-(range,0) then (0,1)-(range,1) etc.
"SetValue" & "GetValue" do exactly what they say with an input of the two coordinates.
"Neighbours" Scans for the number of neighbours with a certain value neighbours.
"GetWorldPosition" coverts the x,y coordinates into a vector 3 that "Neighbours" can use.
Is there anyway to do the "SetValue" after the for loops are done? Can I Make an instance of the grid perhaps (if so, how?)? Would those methods solve my problem? This is one of my first projects so bare with me.
Just create a list of all the changes you are about to make, and complete them after the loop in order. List<(int x, int y, int funkyNumber)>
Note I am not sure if you can use ValueTuples in unity these days. If you can't, you could just create your own struct
Example
var list = new List<(int x, int y, int funkyNumber)>();
GetXY(worldposition, out int originx, out int originy);
for (int x = 0; x < range; x++)
{
for (int y = 0; y < range; y++)
{
Debug.Log(GetValue(originx + x, originy + y));
if ((GetValue(originx + x, originy + y)) == 100)
{
if (Neighbours(GetWorldPosition(x, y), 2) < 2)
list.Add((x, y, 0));
if (Neighbours(GetWorldPosition(x, y), 2) > 3)
list.Add((x, y, 0));
}
if ((GetValue(originx + x, originy + y)) == 0)
{
if (Neighbours(GetWorldPosition(x, y), 2) == 3)
list.Add((x, y, 100));
}
}
}
foreach (var item in list)
SetValue(item.x,item.y,item.funkyNumber)
I am writing a game of minesweeper. Below is code for 3 methods in minesweeper. The first method is to check all the spaces around the button pressed and to count how many bombs are around it. The next method is to be called recursively, in order that if the user pressed a button with 0 buttons around it, it will open all of the squares that also indicate 0 squares around it. The third method is to check that it will be in bound the check. The empty space recursive call is getting me a stackoverflow error, what am I doing wrong?
Thanks!
private int GameLogicChecker(int x, int y)
{
int count = 0;
if (_grid[x, y] != -1)
{
if (x + 1 < SizeX)
{ //Right
if (_grid[x + 1, y] == -1)
count++;
}
if (x - 1 > 0)
{ //Left
if (_grid[x - 1, y] == -1)
count++;
}
if (y + 1 < SizeY)
{ //Upper
if (_grid[x, y + 1] == -1)
count++;
}
if (y - 1 > 0)
{ //Lower
if (_grid[x, y - 1] == -1)
count++;
}
if (x + 1 < SizeX && y + 1 < SizeY)
{ //Right-Upper
if (_grid[x + 1, y + 1] == -1)
count++;
}
if (x + 1 < SizeX && y - 1 > 0)
{ //Right-Lower
if (_grid[x + 1, y - 1] == -1)
count++;
}
if (x - 1 > 0 && y + 1 < SizeY)
{ //Left-Upper
if (_grid[x - 1, y + 1] == -1)
count++;
}
if (x - 1 > 0 && y - 1 > 0)
{ //Left-Lower
if (_grid[x - 1, y - 1] == -1)
count++;
}
}
return count;
}
void OpenEmptySpace(int x, int y)
{
for (var k = -1; k <= 1; k++)
{
for (var l = -1; l <= 1; l++)
{
if (CheckBounds(x + k, y + l) && GameLogicChecker(x + k, y + l) == 0)
{
_buttons[x + k, y + l].Text = "0";
OpenEmptySpace(x + k, y + l);
}
}
}
}
private bool CheckBounds(int x, int y)
{
return x >= 0 && x < SizeX && y >= 0 && y < SizeY;
}
For k = 0 and l = 0, you are calling yourself again and again and again...
Thanks to #BenVoigt for pointing out that two zeroes adjacent to each other will also lead to infinite recursion. So, in order to solve that one method is to create a boolean grid too and set a particular cell's value to true if it has been run through once. Assuming the grid is called Explored, I've added the condition for it in the code below.
If you insist on your current code, try changing the condition to:
if (CheckBounds(x + k, y + l)
&& GameLogicChecker(x + k, y + l) == 0
&& !(k == 0 && l == 0)
&& !Explored[x + k, y + l])
{
Explored[x + k, y + l] = true;
_buttons[x + k, y + l].Text = "0";
OpenEmptySpace(x + k, y + l);
}
Here is another answer for you, rewriting your methods one-by-one following better coding practices. Like in the other answer, a boolean grid called Explored[SizeX, SizeY] has been assumed.
1. GameLogicChecker()
private int GameLogicChecker(int x, int y)
{
if (_grid[x, y] == -1) return 0;
int count = 0;
if (x + 1 < SizeX && _grid[x + 1, y] == -1) //Right
{
count++;
}
if (x - 1 > 0 && _grid[x - 1, y] == -1) //Left
{
count++;
}
if (y + 1 < SizeY && _grid[x, y + 1] == -1) //Upper
{
count++;
}
if (y - 1 > 0 && _grid[x, y - 1] == -1) //Lower
{
count++;
}
if (x + 1 < SizeX && y + 1 < SizeY && _grid[x + 1, y + 1] == -1) //Right-Upper
{
count++;
}
if (x + 1 < SizeX && y - 1 > 0 && _grid[x + 1, y - 1] == -1) //Right-Lower
{
count++;
}
if (x - 1 > 0 && y + 1 < SizeY && _grid[x - 1, y + 1] == -1) //Left-Upper
{
count++;
}
if (x - 1 > 0 && y - 1 > 0 && _grid[x - 1, y - 1] == -1) //Left-Lower
{
count++;
}
return count;
}
What's better? Quicker returning from the method for special case. Reduced nesting in If(...) blocks.
2. OpenEmptySpace()
public/private void OpenEmptySpace(int x, int y)
{
for (var deltaX = -1; deltaX <= 1; deltaX += 2)
{
for (var deltaY = -1; deltaY <= 1; deltaY += 2)
{
var thisX = x + deltaX;
var thisY = y + deltaY;
if (OpeningNotNeeded(thisX, thisY))
{
continue;
}
Explored[thisX, thisY] = true;
_buttons[thisX, thisY].Text = "0";
OpenEmptySpace(thisX, thisY);
}
}
}
private bool OpeningNotNeeded(int x, int y)
{
return !CheckBounds(x, y)
|| GameLogicChecker(x, y) != 0
|| Explored[x, y];
}
What's better? Properly named indexing variables in both loops. Properly written condition (+= 2 instead of ++). Reduced nesting in If(...). Easier to read method call in the If(...) instead of three predicates. Useful temporary variables added which make it clear what x + k and y + l were in the code written earlier.
3. CheckBounds() is written fine.
Can somebody please explain how this recursive function is doing? I'm struggling to understand how you can multiply numbers by using just +
static int Multiply(int x, int y)
{
if (y == 1)
{
return x;
}
else
{
return x + Multiply(x, y - 1);
}
}
Remember your basic arithmetic.
X * 2 = X + X
X * 3 = X + X + X
etc.
So I can factorise X * 3 as
X * 3 = X + (X * 2)
so in the function you have:
X * Y = X + (X * (Y-1))
Therefore
X * Y = Multiply(X, Y) = (X + Multiply(X, Y -1))
Which is essentially the recursion.
To explain with an Example...
Multiply(5, 4) will call
Multiply(5, 3) will call
Multiply(5, 2) will call
Multiply(5, 1)
For each call it will cumulatively add 5 like
5 + 5 + 5 + 5 = 20
Good Luck!
Simple. For e.g.
5 + 5 + 5 = 5 x 3
We can simply put this as Multiply(5, 3)
it is :
x + y(count)-1.
x+(x + (y count-1))
Example :
if x=3 y=4
x+((y-1))
3+(3)=> iteration1
3+(3+3) => iteration 2
3+(3+3+3) => iteration 3
Final => 3+(3+3+3)
Result => 12
Recursion is not the way to go for this requirement given stack limits. Also, evaluate your function with (1, 0) to observe the case where y is less than 1.
Here's a way to "multiply" using addition only with the aid of incrementing which is arguably +/- 1 addition:
static int Multiply(int x, int y)
{
int result = 0;
while (y > 0)
{
result += x;
y--;
}
while (y < 0)
{
result -= x;
y++;
}
return result;
}
That method is not correct because it crashes when you try to multiply by zero.
I wrote a correct method.
public static int Product(int a, int b)
{
if (a == 0 || b == 0) return 0;
else return a + Product(a,b - 1);
}
I've solved Polygon problem problem at interviewstreet, but it seems too slow. What is the best solution to the problem?
There are N points on X-Y plane with integer coordinates (xi, yi). You are given a set of polygons with all of its edges parallel to the axes (in other words, all angles of the polygons are 90 degree angles and all lines are in the cardinal directions. There are no diagonals). For each polygon your program should find the number of points lying inside it (A point located on the border of polygon is also considered to be inside the polygon).
Input:
First line two integers N and Q. Next line contains N space separated integer coordinates (xi,yi). Q queries follow. Each query consists of a single integer Mi in the first line, followed by Mi space separated integer coordinates (x[i][j],y[i][j]) specifying the boundary of the query polygon in clock-wise order.
Polygon is an alternating sequence of vertical line segments and horizontal line segments.
Polygon has Mi edges, where (x[i][j],y[i][j]) is connected to (x[i][(j+1)%Mi], y[i][(j+1)%Mi].
For each 0 <= j < Mi, either x[i][(j+1)%Mi] == x[i][j] or y[i][(j+1)%Mi] == y[i][j] but not both.
It is also guaranteed that the polygon is not self-intersecting.
Output:
For each query output the number of points inside the query polygon in a separate line.
Sample Input #1:
16 2
0 0
0 1
0 2
0 3
1 0
1 1
1 2
1 3
2 0
2 1
2 2
2 3
3 0
3 1
3 2
3 3
8
0 0
0 1
1 1
1 2
0 2
0 3
3 3
3 0
4
0 0
0 1
1 1
1 0
Sample Output #1:
16
4
Sample Input #2:
6 1
1 1
3 3
3 5
5 2
6 3
7 4
10
1 3
1 6
4 6
4 3
6 3
6 1
4 1
4 2
3 2
3 3
Sample Output #2:
4
Constraints:
1 <= N <= 20,000
1 <= Q <= 20,000
4 <= Mi <= 20
Each co-ordinate would have a value of atmost 200,000
I am interested in solutions in mentioned languages or pseudo code.
EDIT: here is my code but it's O(n^2)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Polygon
{
// avoding System.Drawing dependency
public struct Point
{
public int X { get; private set; }
public int Y { get; private set; }
public Point(int x, int y)
: this()
{
X = x;
Y = y;
}
public override int GetHashCode()
{
return X ^ Y;
}
public override bool Equals(Object obj)
{
return obj is Point && this == (Point)obj;
}
public static bool operator ==(Point a, Point b)
{
return a.X == b.X && a.Y == b.Y;
}
public static bool operator !=(Point a, Point b)
{
return !(a == b);
}
}
public class Solution
{
static void Main(string[] args)
{
BasicTestCase();
CustomTestCase();
// to read from STDIN
//string firstParamsLine = Console.ReadLine();
//var separator = new char[] { ' ' };
//var firstParams = firstParamsLine.Split(separator);
//int N = int.Parse(firstParams[0]);
//int Q = int.Parse(firstParams[1]);
//List<Point> points = new List<Point>(N);
//for (int i = 0; i < N; i++)
//{
// var coordinates = Console.ReadLine().Split(separator);
// points.Add(new Point(int.Parse(coordinates[0]), int.Parse(coordinates[1])));
//}
//var polygons = new List<List<Point>>(Q); // to reduce realocation
//for (int i = 0; i < Q; i++)
//{
// var firstQ = Console.ReadLine().Split(separator);
// int coordinatesLength = int.Parse(firstQ[0]);
// var polygon = new List<Point>(coordinatesLength);
// for (int j = 0; j < coordinatesLength; j++)
// {
// var coordinates = Console.ReadLine().Split(separator);
// polygon.Add(new Point(int.Parse(coordinates[0]), int.Parse(coordinates[1])));
// }
// polygons.Add(polygon);
//}
//foreach (var polygon in polygons)
//{
// Console.WriteLine(CountPointsInPolygon(points, polygon));
//}
}
private static void BasicTestCase()
{
List<Point> points = new List<Point>(){ new Point(0, 0),
new Point(0, 1),
new Point(0, 2),
new Point(0, 3),
new Point(1, 0),
new Point(1, 1),
new Point(1, 2),
new Point(1, 3),
new Point(2, 0),
new Point(2, 1),
new Point(2, 2),
new Point(2, 3),
new Point(3, 0),
new Point(3, 1),
new Point(3, 2),
new Point(3, 3) };
List<Point> polygon1 = new List<Point>(){ new Point(0, 0),
new Point(0, 1),
new Point(2, 1),
new Point(2, 2),
new Point(0, 2),
new Point(0, 3),
new Point(3, 3),
new Point(3, 0)};
List<Point> polygon2 = new List<Point>(){ new Point(0, 0),
new Point(0, 1),
new Point(1, 1),
new Point(1, 0),};
Console.WriteLine(CountPointsInPolygon(points, polygon1));
Console.WriteLine(CountPointsInPolygon(points, polygon2));
List<Point> points2 = new List<Point>(){new Point(1, 1),
new Point(3, 3),
new Point(3, 5),
new Point(5, 2),
new Point(6, 3),
new Point(7, 4),};
List<Point> polygon3 = new List<Point>(){ new Point(1, 3),
new Point(1, 6),
new Point(4, 6),
new Point(4, 3),
new Point(6, 3),
new Point(6, 1),
new Point(4, 1),
new Point(4, 2),
new Point(3, 2),
new Point(3, 3),};
Console.WriteLine(CountPointsInPolygon(points2, polygon3));
}
private static void CustomTestCase()
{
// generated 20 000 points and polygons
using (StreamReader file = new StreamReader(#"in3.txt"))
{
string firstParamsLine = file.ReadLine();
var separator = new char[] { ' ' };
var firstParams = firstParamsLine.Split(separator);
int N = int.Parse(firstParams[0]);
int Q = int.Parse(firstParams[1]);
List<Point> pointsFromFile = new List<Point>(N);
for (int i = 0; i < N; i++)
{
var coordinates = file.ReadLine().Split(separator);
pointsFromFile.Add(new Point(int.Parse(coordinates[0]), int.Parse(coordinates[1])));
}
var polygons = new List<List<Point>>(Q); // to reduce realocation
for (int i = 0; i < Q; i++)
{
var firstQ = file.ReadLine().Split(separator);
int coordinatesLength = int.Parse(firstQ[0]);
var polygon = new List<Point>(coordinatesLength);
for (int j = 0; j < coordinatesLength; j++)
{
var coordinates = file.ReadLine().Split(separator);
polygon.Add(new Point(int.Parse(coordinates[0]), int.Parse(coordinates[1])));
}
polygons.Add(polygon);
}
foreach (var polygon in polygons)
{
Console.WriteLine(CountPointsInPolygon(pointsFromFile, polygon));
}
}
}
public static int CountPointsInPolygon(List<Point> points, List<Point> polygon)
{
// TODO input check
polygon.Add(polygon[0]); // for simlicity
// check if any point is outside of the bounding box of the polygon
var minXpolygon = polygon.Min(p => p.X);
var maxXpolygon = polygon.Max(p => p.X);
var minYpolygon = polygon.Min(p => p.Y);
var maxYpolygon = polygon.Max(p => p.Y);
// ray casting algorithm (form max X moving to point)
int insidePolygon = 0;
foreach (var point in points)
{
if (point.X >= minXpolygon && point.X <= maxXpolygon && point.Y >= minYpolygon && point.Y <= maxYpolygon)
{ // now points are inside the bounding box
isPointsInside(polygon, point, ref insidePolygon);
} // else outside
}
return insidePolygon;
}
private static void isPointsInside(List<Point> polygon, Point point, ref int insidePolygon)
{
int intersections = 0;
for (int i = 0; i < polygon.Count - 1; i++)
{
if (polygon[i] == point)
{
insidePolygon++;
return;
}
if (point.isOnEdge(polygon[i], polygon[i + 1]))
{
insidePolygon++;
return;
}
if (Helper.areIntersecting(polygon[i], polygon[i + 1], point))
{
intersections++;
}
}
if (intersections % 2 != 0)
{
insidePolygon++;
}
}
}
static class Helper
{
public static bool isOnEdge(this Point point, Point first, Point next)
{
// onVertical
if (point.X == first.X && point.X == next.X && point.Y.InRange(first.Y, next.Y))
{
return true;
}
//onHorizontal
if (point.Y == first.Y && point.Y == next.Y && point.X.InRange(first.X, next.X))
{
return true;
}
return false;
}
public static bool InRange(this int value, int first, int second)
{
if (first <= second)
{
return value >= first && value <= second;
}
else
{
return value >= second && value <= first;
}
}
public static bool areIntersecting(Point polygonPoint1, Point polygonPoint2, Point vector2End)
{
// "move" ray up for 0.5 to avoid problem with parallel edges
if (vector2End.X < polygonPoint1.X )
{
var y = (vector2End.Y + 0.5);
var first = polygonPoint1.Y;
var second = polygonPoint2.Y;
if (first <= second)
{
return y >= first && y <= second;
}
else
{
return y >= second && y <= first;
}
}
return false;
}
}
}
A faster solution is to place the points into a quadtree.
A region quadtree might be easier to code, but a point quadtree is probably faster. If using a region quadtree then it can help to stop subdividing the quadtree when the number of points in a quad falls below a threshold (say 16 points)
Each quad stores the number of points it contains, plus either a list of coordinates (for leaf nodes) or pointers to smaller quads. (You can omit the list of coordinates when the size of the quad reaches 1 as they must all be coincident)
To count the points inside the polygon you look at the largest quad that represents the root of the quadtree.
Clip the polygon to the edges of the quad
If the polygon does not overlap the quad then return 0
If this is a quad of size 1x1 then return the number of points in the quad
If the polygon totally encircles the quad then return the number of points in the quad.
If this is a leaf node then test each point with the plumb line algorithm
Otherwise recursively count the points in each child quad
(If a quad only has one non-empty child then you can skip steps 1,2,3,4,5 to go a little faster)
(The tests in 2 and 4 do not have to be totally accurate)
Does trapezoidal decomposition work for you?
I refer you to Jordan Curve Theorem and the Plumb Line Algorithm.
The relevant pseudocode is
int crossings = 0
for (each line segment of the polygon)
if (ray down from (x,y) crosses segment)
crossings++;
if (crossings is odd)
return (inside);
else return (outside);
I would try casting a ray up from the bottom to each point, tracking where it crossed into the polygon (passing a right-to-left segment) or back out of the polygon (passing a left-to-right segment). Something like this:
count := 0
For each point (px, py):
inside := false
For each query line (x0, y0) -> (x1, y1) where y0 = y1
if inside
if x0 <= px < x1 and py > y0
inside = false
else
if x1 <= px <= x0 and py >= y0
inside = true
if inside
count++
The > vs. >= in the two cases is so that a point on the upper edge is considered inside. I haven't actually coded this up to see if it works, but I think the approach is sound.
Here is the solution from authors - a bit obfuscated, isn't it?
#include <iostream>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <ctime>
using namespace std;
typedef long long int64;
const int N = 100000, X = 2000000001;
const int Q = 100000, PQ = 20;
struct Point {
int x, y, idx;
Point(int _x = 0, int _y = 0, int _idx = 0) {
x = _x;
y = _y;
idx = _idx;
}
} arr_x[N], arr_y[N];
struct VLineSegment {
int x, y1, y2, idx, sign;
VLineSegment(int _x = 0, int _y1 = 0, int _y2 = 0, int _sign = 1, int _idx = 0) {
x = _x;
y1 = _y1;
y2 = _y2;
sign = _sign;
idx = _idx;
}
bool operator<(const VLineSegment& v) const {
return x < v.x;
}
} segs[Q * PQ];
struct TreeNode {
int idx1, idx2, cnt;
TreeNode *left, *right;
TreeNode() { left = right = 0; cnt = 0; }
~TreeNode() { if(left) delete left; if(right) delete right; }
void update_stat() {
cnt = left->cnt + right->cnt;
}
void build(Point* arr, int from, int to, bool empty) {
idx1 = from;
idx2 = to;
if(from == to) {
if(!empty) {
cnt = 1;
} else {
cnt = 0;
}
} else {
left = new TreeNode();
right = new TreeNode();
int mid = (from + to) / 2;
left->build(arr, from, mid, empty);
right->build(arr, mid + 1, to, empty);
update_stat();
}
}
void update(Point& p, bool add) {
if(p.idx >= idx1 && p.idx <= idx2) {
if(idx1 != idx2) {
left->update(p, add);
right->update(p, add);
update_stat();
} else {
if(add) {
cnt = 1;
} else {
cnt = 0;
}
}
}
}
int query(int ya, int yb) {
int y1 = arr_y[idx1].y, y2 = arr_y[idx2].y;
if(ya <= y1 && y2 <= yb) {
return cnt;
} else if(max(ya, y1) <= min(yb, y2)) {
return left->query(ya, yb) + right->query(ya, yb);
}
return 0;
}
};
bool cmp_x(const Point& a, const Point& b) {
return a.x < b.x;
}
bool cmp_y(const Point& a, const Point& b) {
return a.y < b.y;
}
void calc_ys(int x1, int y1, int x2, int y2, int x3, int sign, int& ya, int& yb) {
if(x2 < x3) {
yb = 2 * y2 - sign;
} else {
yb = 2 * y2 + sign;
}
if(x2 < x1) {
ya = 2 * y1 + sign;
} else {
ya = 2 * y1 - sign;
}
}
bool process_polygon(int* x, int* y, int cnt, int &idx, int i) {
for(int j = 0; j < cnt; j ++) {
//cerr << x[(j + 1) % cnt] - x[j] << "," << y[(j + 1) % cnt] - y[j] << endl;
if(x[j] == x[(j + 1) % cnt]) {
int _x, y1, y2, sign;
if(y[j] < y[(j + 1) % cnt]) {
_x = x[j] * 2 - 1;
sign = -1;
calc_ys(x[(j + cnt - 1) % cnt], y[j], x[j], y[(j + 1) % cnt], x[(j + 2) % cnt], sign, y1, y2);
} else {
_x = x[j] * 2 + 1;
sign = 1;
calc_ys(x[(j + 2) % cnt], y[(j + 2) % cnt], x[j], y[j], x[(j + cnt - 1) % cnt], sign, y1, y2);
}
segs[idx++] = VLineSegment(_x, y1, y2, sign, i);
}
}
}
int results[Q];
int n, q, c;
int main() {
int cl = clock();
cin >> n >> q;
for(int i = 0; i < n; i ++) {
cin >> arr_y[i].x >> arr_y[i].y;
arr_y[i].x *= 2;
arr_y[i].y *= 2;
}
int idx = 0, cnt, x[PQ], y[PQ];
for(int i = 0; i < q; i ++) {
cin >> cnt;
for(int j = 0; j < cnt; j ++) cin >> x[j] >> y[j];
process_polygon(x, y, cnt, idx, i);
}
sort(segs, segs + idx);
memset(results, 0, sizeof results);
sort(arr_y, arr_y + n, cmp_y);
for(int i = 0; i < n; i ++) {
arr_y[i].idx = i;
arr_x[i] = arr_y[i];
}
sort(arr_x, arr_x + n, cmp_x);
TreeNode tleft;
tleft.build(arr_y, 0, n - 1, true);
for(int i = 0, j = 0; i < idx; i ++) {
for(; j < n && arr_x[j].x <= segs[i].x; j ++) {
tleft.update(arr_x[j], true);
}
int qcnt = tleft.query(segs[i].y1, segs[i].y2);
//cerr << segs[i].x * 0.5 << ", " << segs[i].y1 * 0.5 << ", " << segs[i].y2 * 0.5 << " = " << qcnt << " * " << segs[i].sign << endl;
results[segs[i].idx] += qcnt * segs[i].sign;
}
for(int i = 0; i < q; i ++) {
cout << results[i] << endl;
}
cerr << (clock() - cl) * 0.001 << endl;
return 0;
}
I'm trying to implement Improved Noise in my XNA game, but my Improved Noise function keeps returning 0.0f. It's the exact same code as Ken Perlin's (http://mrl.nyu.edu/~perlin/noise/), just ported to C#.
I've tried rewriting the class and even copy and pasting directly from the site (and then porting to C#, of course), but it just won't output any value but 0.
Here's the code that I'm using:
public class PerlinNoise
{
private int[] permutations = new int[512];
private Random random;
public PerlinNoise()
: this(Environment.TickCount)
{ }
public PerlinNoise(int seed)
{
random = new Random(seed);
for (int i = 0; i < 256; i++)
{
permutations[i] = i;
}
for (int i = 0; i < 256; i++)
{
int k = random.Next(256 - i) + i;
int l = permutations[i];
permutations[i] = permutations[k];
permutations[k] = l;
permutations[i + 256] = permutations[i];
}
}
private int fastfloor(float x)
{
return x > 0 ? (int)x : (int)x - 1;
}
private float fade(float t)
{
return t * t * t * (t * (t * 6 - 15) + 10);
}
private float lerp(float t, float a, float b)
{
return a + t * (b - a);
}
public float grad(int hash, float x, float y, float z)
{
int h = hash & 15;
float u = h < 8 ? x : y,
v = h < 4 ? y : h == 12 || h == 14 ? x : z;
return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
}
public float noise3d(float x, float y, float z)
{
int X = fastfloor(x) & 0xff,
Y = fastfloor(y) & 0xff,
Z = fastfloor(z) & 0xff;
x -= fastfloor(x);
y -= fastfloor(y);
z -= fastfloor(z);
float u = fade(x);
float v = fade(y);
float w = fade(z);
int A = permutations[X] + Y, AA = permutations[A] + Z, AB = permutations[A + 1] + Z,
B = permutations[X + 1] + Y, BA = permutations[B] + Z, BB = permutations[B + 1] + Z;
return lerp(w, lerp(v, lerp(u, grad(permutations[AA], x, y, z),
grad(permutations[BA], x - 1, y, z)),
lerp(u, grad(permutations[AB], x, y - 1, z),
grad(permutations[BB], x - 1, y - 1, z))),
lerp(v, lerp(u, grad(permutations[AA + 1], x, y, z - 1),
grad(permutations[BA + 1], x - 1, y, z - 1)),
lerp(u, grad(permutations[AB + 1], x, y - 1, z - 1),
grad(permutations[BB + 1], x - 1, y - 1, z - 1))));
}
public float noise2d(float x, float y)
{
return noise3d(x, y, 0f);
}
} `
To test it, I simply did:
string[] args = Console.ReadLine().Split(' ');
PerlinNoise noise = new PerlinNoise();
int x = args[0];
int y = args[1];
int z = args[2];
Console.WriteLine(noise.noise3d(x, y, z));
And as I said above, it'll always output 0.
It seems to output 0.0f if all arguments are integral numbers. Change your testing code to
var input = Console.ReadLine()
.Split(' ')
.Select(s => float.Parse(s,
System.Globalization.CultureInfo.InvariantCulture))
.ToArray();
and try to enter, for example, 4234.2123 3123.12312 423.2434.
I'm not quite sure if it is desired behavior, but
x -= Math.Floor(x); // FIND RELATIVE X,Y,Z
y -= Math.Floor(y); // OF POINT IN CUBE.
z -= Math.Floor(z);
will always make x, y & z = 0 if they are integral numbers; fade(0.0f) is also always zero.
Multiply your inputs by (1 / MAX_VALUE) in your input case, just multiply by 1 / 256 or so, and never give it anything larger than that. When used in your game, multiply the input by (1 / MAXIMUM_CHOORD_VALUE).