How can write a mapping program in c++ - c++

Question

I have a question about c++ and a problem which I have to solve. Actually, I don't have any idea about solving this problem. I'd be delighted if anyone could help me and give me any clues. Thanks
I want to print the output for every 2 natural numbers a, b which make a/b fraction.
for example for the number (2) it should print 1 1 in the output because we don't consider (0,0) and the second point which we reach in the coordinate on the spiral path is (1,1).
the input should be a natural number and the output should be vertical and horizontal coordinate.
for example, the input is 12 and its output is 2 2.
more information is here in these photos:

Answer 1

Nice question, not that easy to implement.
The approach is to first analyze the requirements, then do a design, refine the design until it is OK and finally, at the very end, write the code.
Let us look at the requirements
We have coordinate system, where we will move in
Movement will follow a spiral pattern
Already occupied coordinates in the coordinate system, cannot be reused
Fractions shall be generated, derived from the position in the coordinate system
Since a position with a column 0 would result in an illegal 0-denominator, the coordinate system will not have a column 0.
So, after moving to a new position, a reduced unique fraction shall be generated
A given number of moves shall be performed
According to the description, it would be sufficient to just show the last reduced fraction as a result. However, the whole sequence is of interest
Good. Now we have analyzed those requirements and know, what should be done.
Next step. We start to think on how the requirements shall be implemented.
Obviously, we need some implementation of a “fraction” class. The fraction class will only store reduced fractions. The sign will be normalized. Meaning, if there are signs, they are evaluated and if the resulting fraction is negative, the numerator will get the minus sign. All fractions having a 0 as numerator, will get a 1 as denominator. We use the one, because later, during output we will suppress the output of “1” denominator and show just the numerator.
All this we will do during creation of the fraction using the constructor. That is somehow simple.
The requirement of unique fractions, can be solved by storing them in an appropriate container. Because the order is not important (only the uniqueness), we can use a std::unordered_set. This has the additional advantage that we have fast access via hash algorithms. For that we need to add a hash function and an equal operator to our fraction class.
For reducing fractions, we will use the standard approach and divide numerator and denominator by the greatest common divisor (GCD). Luckily C++ has a ready to use function for this.
Last, but not least, we will overwrite the inserter operator <<, for generating some output easily.
Now, moving along a spiral pattern. A spiral pattern can be created by folling the following approach.
We have a start position and a start direction
Depending on the direction we will look for a potential next position and next direction. The idea to get a spiral is the following:
If current direction is right, then the preferred next direction is up
If current direction is up, then the preferred next direction is left
If current direction is left, then the preferred next direction is down
If current direction is down, then the preferred next direction is right
All the above of course only, if that new position is not occupied
To check, if a position is occupied, we will store all visited positions as unique value in a container.
We again need select the std::unordered_set
We need to add a hash functor for this
If the potential new position, calculated with the above logic, is free (not occupied / not in our std::unordered_set), then we will add the new position to it.
If the potential next position is already occupied, then we continue to move in the original direction
Moving along columns, we have to skip column 0. It is not existing.
After having the new position, we create a (reduced) fraction out of it. The row of the position will be the numerator, the column will be the denominator
Then, we check, if we have seen this fraction already, by trying to insert it into the above described std::unordered_set for the fractions (do not mix up with container for positions)
If it could be inserted, then it was not in before, so, it is no duplicate, and can be put into the result-vector
All the above (and a little bit more) can now be implemented into code.
This will lead to one of many potential solutions:
#include <iostream>
#include <numeric>
#include <vector>
#include <utility>
#include <unordered_set>
struct RFraction {
// We will store reduced fractions. And show numerator and denominator separately
int numerator{};
int denominator{};
// Contructor will take a fraction, a nominater and denominater, reduce the fraction and mormalize the sign
RFraction(const int n, const int d) : numerator(std::abs(n)), denominator(std::abs(d)) {
if (n == 0) denominator = 1; // All faction with a 0 numerator will get a 1 as denominator
reduce(); // Reduce fraction
if ((n < 0 and d >= 0) or (n >= 0 and d < 0)) numerator = -numerator; // Handle sign uniformly
}
// Simple reduce function using standardapproach with gcd
void reduce() { int gcd = std::gcd(numerator, denominator); numerator /= gcd; denominator /= gcd; }
// Hash Functor
struct Hash { size_t operator()(const RFraction& r) const { return std::hash<int>()(r.numerator) ^ std::hash<int>()(r.denominator); } };
// Equality, basedon fraction and not on a double
bool operator == (const RFraction& other) const { return numerator == other.numerator and denominator == other.denominator; }
// Simple output
friend std::ostream& operator << (std::ostream& os, const RFraction& f) {
if (f.denominator == 1) os << f.numerator;
else os << f.numerator << " / " << f.denominator;
return os;
}
};
using Position = std::pair<int, int>;
struct PairHash { std::size_t operator() (const Position& p) const { return std::hash<int>()(p.first) ^ std::hash<int>()(p.second); } };
using Matrix = std::unordered_set<Position, PairHash>;
using Sequence = std::vector<RFraction>;
using UniqueRFraction = std::unordered_set<RFraction, RFraction::Hash>;
enum class Direction { right, up, left, down };
Sequence getSequence(const size_t maxIndex) {
// Current position and direction
Position position{ 0,2 };
Direction direction{ Direction::right };
// Here we will store all occupied positions
Matrix matrix{ {0,1}, {0,2} };
// Thsi is a helper to store in the end only unique fractions
UniqueRFraction uniqueRFraction{ {0,1} };
// Result. All unique fractions along the path
Sequence result{ {0,1} };
// Find all elements of the sequence
for (size_t k{}; k < maxIndex; ) {
Position potentialNextPosition(position);
// Depending of the current direction, we want to get new position and new direction
switch (direction) {
case Direction::right:
// Check position above. Get position above current position
++potentialNextPosition.first;
// Check, if this is already occupied
if (matrix.count(potentialNextPosition) == 0) {
// If not occupied then use this new direction and the new position
direction = Direction::up;
position = potentialNextPosition;
}
// Keep on going right
else if(++position.second == 0) ++position.second;
break;
case Direction::up:
// Check position left. Get position left of current position
if(--potentialNextPosition.second == 0) --potentialNextPosition.second;
// Check, if this is already occupied
if (matrix.count(potentialNextPosition) == 0) {
// If not occupied then use this new direction and the new position
direction = Direction::left;
position = potentialNextPosition;
}
// Keep on going up
else ++position.first;
break;
case Direction::left:
// Check position below. Get position below current position
--potentialNextPosition.first;
// Check, if this is already occupied
if (matrix.count(potentialNextPosition) == 0) {
// If not occupied then use this new direction and the new position
direction = Direction::down;
position = potentialNextPosition;
}
// Keep on going left
else if (--position.second == 0) --position.second;
break;
case Direction::down:
// Check position right. Get position right of current position
if (++potentialNextPosition.second == 0) ++potentialNextPosition.second;
// Check, if this is already occupied
if (matrix.count(potentialNextPosition) == 0) {
// If not occupied then use this new direction and the new position
direction = Direction::right;
position = potentialNextPosition;
}
// Keep on going down
else --position.first;
break;
}
// Add new position to the matrix, to indicate that it is occuppied
matrix.insert(position);
// Check, if the fraction, created out of the position, is unique. If so, the add it to the result
if (const auto [iter, isOK] = uniqueRFraction.insert({ position.first, position.second }); isOK) {
result.push_back(*iter);
++k;
}
}
return result;
}
int main() {
// Calculate the sequence of fractions up to a given index (index starts with 0)
Sequence seq = getSequence(25);
// Shwo the result
std::cout << "\nResult: \t" << seq.back() << "\n\nSequence:\n\n";
// And for debug purposes, also the complete sequence.
for (size_t k{}; k < seq.size(); ++k)
std::cout << k << '\t' << seq[k] << '\n';
return 0;
}