Spiraali

input/code.cpp: In function 'uint64_t GetSpiralValue(int, const Int2&)':
input/code.cpp:30:25: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for (uint64_t i = 0; i < ringInToCenter; i++)
                       ~~^~~~~~~~~~~~~~~~

#include <iostream>
#include <cmath>

struct Int2
{
	int x, y;
};

uint64_t GetSpiralValue(int size, const Int2& pos)
{
	// Position relative to the center
	Int2 positionRel = 
	{ 
		pos.x >= size / 2 ? pos.x - size / 2 : pos.x - size / 2 + 1, 
		pos.y >= size / 2 ? pos.y - size / 2 : pos.y - size / 2 + 1
	};
	// Distance form center for each axis
	Int2 distance =
	{
		std::abs(positionRel.x),
		std::abs(positionRel.y)
	};
	// Maximum distance from the center tells witch ring it is.
	// Maybe can be optimized, but no.
	int ringFromCenter = std::max(distance.x, distance.y);
	int ringInToCenter = (ringFromCenter <= size / 2 ? size / 2 - ringFromCenter : (size / 2 + 1) - ringFromCenter) - 1;

	// Can be optimized as its a linear sum (I think). Set to 0 as distanceInRing is 1 higher then it should be
	uint64_t ringStartPoint = 1;
	for (uint64_t i = 0; i < ringInToCenter; i++)
	{
		//ringStartPoint += 2 * (size - 2 * i) + 2 * ((size - 2) - 2 * i);
		ringStartPoint += -8 * i + 4 * (uint64_t)size - 4;
	}

	uint64_t distanceInRing;

	// Function like this will be used in every single one derived
	// distanceInRing += 2 * (size - 2 * ringInToCenter) + 2 * ((size - 2) - 2 * ringInToCenter) - (uint64_t)(2*ringFromCenter + positionRel.y);

	if (positionRel.x < 0 && positionRel.y < 0 && positionRel.x == positionRel.y)
	{
		return ringStartPoint;
	}
	else if (distance.x == ringFromCenter)
	{
		if (positionRel.x < 0)
		{
			if (ringFromCenter == 0)
				distanceInRing = 1;
			else
				distanceInRing = (uint64_t)(2 * ringInToCenter + positionRel.y);
		}
		else
		{
			if (ringFromCenter == 0)
				distanceInRing = std::abs(positionRel.y) + 2;
			else
				distanceInRing = -6 * (uint64_t)ringInToCenter + 3 * (uint64_t)size - 2 - (uint64_t)(2 * ringFromCenter + positionRel.y);
		}
	}
	else
	{
		if (positionRel.y < 0)
			distanceInRing = (uint64_t)size - 2 * (uint64_t)ringInToCenter + (uint64_t)(2 * ringFromCenter + positionRel.x);
		else
			distanceInRing = -8 * (uint64_t)ringInToCenter + 4 * (uint64_t)size - 4 - (uint64_t)(2 * ringFromCenter + positionRel.x);
	}

	return ringStartPoint + distanceInRing;
}

int main()
{
	int n, t;
	std::cin >> n;
	std::cin >> t;
	
	Int2* positions = new Int2[t];

	for (int i = 0; i < t; i++)
	{
		int x, y;
		std::cin >> x;
		std::cin >> y;

		positions[i] = { y - 1, x - 1 };
	}

	for (int i = 0; i < t; i++)
	{
		auto& pos = positions[i];

		std::cout << GetSpiralValue(n, pos) << "\n";
	}

	delete[] positions;
}

Test 1

Group: 1

Verdict: WRONG ANSWER

Test 2

Group: 2

Verdict: WRONG ANSWER

Test 3

Group: 3

Verdict: TIME LIMIT EXCEEDED