Дана последовательность 1 1 2 1 1 2 3 2 1 1 2 3 4 3 2 1

#include "inc.h"
#include "temp.h"
#include "foos.h"
 
 
const int SoLong::cellsize = 8;
const int SoLong::maxsize = 10;
 
void find_in(SoLong &n)
{
    int two = 2;
    SoLong how = sqrt(n);
    how = how*two;
    ++how;
    SoLong max = how/2;
    n=n-(max*max);
 
    ( n<=max ? ++n : n=how-n );
}
 
int main()
{
 
    SoLong a;
    a.input();
    
    find_in(a);
    std::cout << "\n Result: ";
    show(a);
 
    system("pause");
    return(0);
}

#include "inc.h"
 
#ifndef _TEMP_H_
#define _TEMP_H_
 
class SoLong {
private:
    //std::vector<int> number;
    static const int cellsize;
    static const int maxsize;
 
    int arr[10];
    int amount;
 
public:
 
    SoLong()
    {
    //  number.reserve(10);
        memset(arr,0,sizeof(arr));
        amount = 9;
    }
 
    void setAmount()
    {
        int pos = 0;
        while (!arr[pos]) pos++;
        amount = pos-1;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
    //input/output
 
    void input()
    {
        std::string str;
 
        std::cin >> str;
 
        int pos = maxsize-1;
        for (int i=str.size()-1;i>=0;i-=cellsize)
        {
          int start = i - cellsize + 1;
          if (start<0) start = 0;
          std::string dig = str.substr(start,i-start+1);
          arr[pos--] = stoi(dig);
        }
        amount = pos;
    }
 
    void show()
    {
        bool zero_shift = true;
        for(int i=0; i<maxsize; i++)
        {
            if(arr[i]) zero_shift = false;
            if(!zero_shift) 
            {
                std::cout << std::setw(this->cellsize) << std::setfill('0') << arr[i] << " ";
            }
        }
    }
 
    friend void show(SoLong &a);
 
    //*******
    //compare
    friend bool operator>(SoLong &a, SoLong &b);
    friend bool operator>=(SoLong &a, SoLong &b);
    friend bool operator<(SoLong &a, SoLong &b);
    friend bool operator<=(SoLong &a, SoLong &b);
    friend bool operator==(SoLong &a, SoLong &b);
    //******************************************
    //+-/*sqrt
    SoLong &operator=(SoLong &another)
    {
        memcpy(this->arr,another.arr, sizeof(int)*this->maxsize);
        this->amount = another.amount;
 
        return *this;
    }
 
    friend SoLong sqrt(SoLong &a);
 
    friend SoLong operator*(SoLong &a, int b);
    friend SoLong operator*(SoLong &a, SoLong &b);
    
    friend SoLong operator/(SoLong &a, int n);
    friend SoLong operator-(SoLong &a, SoLong &b);
    friend SoLong operator++(SoLong &a);
 
 
};
 
#endif

#include "inc.h"
#include "temp.h"
 
void show(SoLong &a)
{
    a.show();
}
 
bool operator>(SoLong &a, SoLong &b)
{
    if(a.amount < b.amount) return true;
    if(a.amount > b.amount) return false;
    for(int i=a.amount; i<a.maxsize; i++)
    {
        if(a.arr[i] > b.arr[i]) return true;
        if(a.arr[i] < b.arr[i]) return false;
    }
    return false;
}
 
bool operator>=(SoLong &a, SoLong &b)
{
    if(a.amount < b.amount) return true;
    if(a.amount > b.amount) return false;
    for(int i=a.amount; i<a.maxsize; i++)
    {
        if(a.arr[i] > b.arr[i]) return true;
        if(a.arr[i] < b.arr[i]) return false;
    }
    return true;
}
 
bool operator<(SoLong &a, SoLong &b)
{
    if(a.amount > b.amount) return true;
    if(a.amount < b.amount) return false;
    for(int i=a.amount; i<a.maxsize; i++)
    {
        if(a.arr[i] < b.arr[i]) return true;
        if(a.arr[i] > b.arr[i]) return false;
    }
    return false;
}
 
bool operator<=(SoLong &a, SoLong &b)
{
    if(a.amount > b.amount) return true;
    if(a.amount < b.amount) return false;
    for(int i=a.amount; i<a.maxsize; i++)
    {
        if(a.arr[i] < b.arr[i]) return true;
        if(a.arr[i] > b.arr[i]) return false;
    }
    return true;
}
 
bool operator==(SoLong &a, SoLong &b)
{
    if(a.amount > b.amount) return false;
    if(a.amount < b.amount) return false;
    for(int i=a.amount; i<a.maxsize; i++)
    {
        if(a.arr[i] < b.arr[i]) return false;
        if(a.arr[i] > b.arr[i]) return false;
    }
    return true;
}
 
SoLong operator*(SoLong &a, SoLong &b)
{
    SoLong res;
 
    for (int i=a.maxsize-1; i>a.amount;i--)
    {
        double r = 0, rr = 0;
        for (int j=b.maxsize-1; j>b.amount; j--)
        {
            int temp = i + j - a.maxsize+1;
            double sotemp = (double)a.arr[i] * (double)b.arr[j];
 
            int x = temp;
            while(sotemp && x >=0)
            {
                sotemp += res.arr[x];
                r = floor(sotemp * 0.00000001);
                res.arr[x] = sotemp - floor(r)*100000000;
                sotemp = r;
                x--;
            }
 
        }
    }
 
    res.setAmount();
 
    return res;
}
 
SoLong operator*(SoLong &a, int b)
{
    SoLong res;
 
    for (int i=a.maxsize-1; i>a.amount;i--)
    {
        double r = 0, rr = 0;
 
            
            double sotemp = (double)a.arr[i] * b;
 
            int x = i;
            while(sotemp && x >=0)
            {
                sotemp += res.arr[x];
                r = floor(sotemp * 0.00000001);
                res.arr[x] = sotemp - floor(r)*100000000;
                sotemp = r;
                x--;
            }
 
    }
    
 
    res.setAmount();
 
    return res;
}
 
SoLong sqrt(SoLong &a)
{
    SoLong cur;
 
    int pos = (a.maxsize+a.amount-1)/2;
    cur.amount = pos;
    pos++;
    while (pos<cur.maxsize)
    {
        int l = 0, r = 99999999;
        int curDigit = 0;
        while (l<=r)
        {
            int m = (l+r)>>1;
            cur.arr[pos] = m;
            if ((cur * cur) <= a)
            {
 
                curDigit = m;
                l = m + 1;
            }
            else r = m - 1;
        }
        cur.arr[pos] = curDigit;
        pos++;
    }
//  cur.setAmount();
    return cur;
 
}
 
SoLong operator/(SoLong &a, int n)
{
  SoLong res;
  res.amount = a.amount;
  int ost = 0;
  for (int i=res.amount;i<res.maxsize;i++)
  {
    int cur = ost * 100000000 + a.arr[i];
    res.arr[i] = cur / n;
    ost = cur % n;
  }
 
  res.setAmount();
  return res;
}
 
SoLong operator-(SoLong &a, SoLong &b)
{
    SoLong  res = a;
    int r = 0;
    for (int i = res.maxsize-1; i>=res.amount; i--)
    {
        res.arr[i] -= b.arr[i] + r;
        if (res.arr[i]<0)
        {
            res.arr[i]+=100000000;
            res.arr[i-1]--;
        }   
    }
    res.setAmount();
 
    return res;
}
 
SoLong operator++(SoLong &a)
{
    int x = a.maxsize-1;
 
    while(a.arr[x] == 99999999)
    {
        a.arr[x] = 0;
        x--;
    }
    a.arr[x]++;
 
    return a;
 
}