void f(int i)
{
   cout << "f(int i):" << i << endl;
}

void f(float i)
{
   cout << "f(float i):" << i << endl;
}


template<class T>
void f(T i)
{
   cout << "f(T i):" << i << endl;
}

int main()
{
  f(1);
  f(1.2);
}

#include <iostream>
using namespace std;

int func()
{
    
    int a;
    cin >> a;
    if(a == 1)
    {
        cout << a << endl;
        return 0;
    }

    int max = a / 2 + 1;
    int num = 0;
    int sum;
    for(int i = 1; i <= max; i++)
    {
        sum = 0;
        for(int j = i; j <= max; j++)
        {
            sum += j;
            if(sum == a)
            {
                for(int k = i; k <= j; k++)
                    cout << k << " ";
                cout << endl;
                num++;
                break;
            }
        }
    }

    if(num == 0)
        cout << "NONE" << endl;

    return 0;
}


int main()
{
    func();
}

#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Num
{
public:
    Num(int m_left, int m_right)
    {
        left = m_left;
        right = m_right;
    }
    int left;
    int right;

    
};

class LessCompare
{
public:
    bool operator()(Num left, Num right)
    {
        return left.left < right.left;
    }
};

void func()
{
    fstream file("input.txt", std::ios_base::in);

    int  num;
    vector<Num> numVector;

    while(file >> num)
    {
        int left = num;
        int right = 0;
        if(file.good())
        {
            file >> num;
            right = num;
        }

        if(left >= right)
        {
            int tmp = left;
            left = right;
            right = tmp;
        }

        Num newNum(left, right);
        numVector.push_back(newNum);
    }

    sort(numVector.begin(), numVector.end(), LessCompare());



    Num pre = numVector[0];
    bool isSame = true;
    vector<Num> newNumVector;
    for(int i = 1; i < numVector.size(); i++)
    {
        Num m_num = numVector[i];
        if(m_num.left == pre.left)
        {
            if(m_num.right > pre.right)
            {
                pre = m_num;
            }
            isSame = true;
        }
        else
        {
            
            newNumVector.push_back(pre);
            isSame = false;
            pre = m_num;
        }
    }

    newNumVector.push_back(pre);



    Num max = newNumVector[0];
    int maxlength = 0;
    for(int i = 1; i < newNumVector.size(); i++)
    {
        Num now = newNumVector[i];
        if(now.left < max.right)
        {
            int length = 0;
            if(max.right < now.right)
            {
                length = max.right - now.left;
            }
            else
                length = now.right - now.left;

            if(length > maxlength)
                maxlength = length;
        }

        if(now.right > max.right)
            max = now;
    }

    cout<< maxlength << endl;

}

int main()
{
    func();
}

#include <iostream>
#include <string>
#include <map>
#include <fstream>
using namespace std;


void dicfunc()
{
    fstream dict("dict.txt", ios_base::in);
    

    map<string, string> dictmap;

    string input;
    while(dict >> input)
    {
        string key = input;
        string value;
        if(dict.good())
        {
            dict >> input;
            value = input;
        }

        dictmap[key] = value;
    }

    dict.close();
    fstream text("text.txt", ios_base::in);
    while(text >> input)
    {
        int count = dictmap.count(input);
        if(count == 0)
            cout << input;
        else
            cout << dictmap[input];

        cout << " ";
    }

    text.close();

}

int main()
{
    dicfunc();
}

#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
#include <limits>
#include <string>
using namespace std;

void removefunc()
{
    fstream corpus("corpus.txt", ios_base::in);

    string str;
    map<string, int> corpusMap;

    int minCount = numeric_limits<int>::max();
    vector<string> minVector;
    while(corpus >> str)
    {
        int isCount = corpusMap.count(str);
        isCount = isCount + 1;
        corpusMap[str] = isCount;
        if(isCount < minCount)
        {
            minCount = isCount;
            minVector.clear();
            minVector.push_back(str);
        } 
        else if(isCount == minCount)
        {
            minVector.push_back(str);
        }
        else
        {
            if((isCount - 1) == minCount)
            {
                vector<string>::iterator iter = find(minVector.begin(), minVector.end(), str);
                minVector.erase(iter);
            }
        }

        cout << isCount << endl;
    }

    for(int i = 0; i < minVector.size(); i++)
    {
        string substr = minVector[i];
        cout << substr << " " << endl;
    }
}


int main()
{
    removefunc();

}