#include <iostream>
#include <random>
#include <vector>
#include <set>

struct Sprite
{
    int x = 0 ; // key
    int y = 0 ;
    // contains lots more stuff 
    // ...

    operator int() const noexcept { return x ; } // to support key compare using int
};

int main()
{
    // note: transparent key comparator
    std::multiset< Sprite, std::less<> > sprites ;

    // insert
    int y = 10 ;
    for( int x : { 1, 2, 1, 3, 4, 1, 5, 1, 6 } ) sprites.insert( { x, ++y } ) ;

    // lookup for x == 1
    for( auto [iter,end] = sprites.equal_range(1) ; iter != end ; ++iter )
        std::cout << "found Sprite with x,y == " << iter->x << ',' << iter->y << '\n' ;

    // modify a sprite
    std::cout << sprites.count(1) << ' ' << sprites.count(999) << '\n' ; // 4 0

    const auto iter = sprites.find(1) ; // find an element with key == 1
    if( iter != sprites.end() )
    {
        auto node_handle = sprites.extract(iter) ; // unlink the node from the set
        node_handle.value().x = 999 ; // modify the Sprite in it
        sprites.insert( std::move(node_handle) ) ; // link the node with the modified sprite into the set
    }

    std::cout << sprites.count(1) << ' ' << sprites.count(999) << '\n' ; // 3 1
}

#include <iostream>

int main() {
	constexpr auto factorial { [](uint64_t n) noexcept {
		constexpr auto f_impl {[](uint64_t n, const auto& impl) noexcept -> uint64_t {
			return n > 1 ? n * impl(n - 1, impl) : 1;
		}};
		return f_impl(n, f_impl);
	} };

	std::cout <<  factorial(5) << '\n';
}

#include <iostream>
#include <string>
#include <vector>
#include "President.h"

using namespace std;

int main()
{
	President<vector<string>>& onlyPresident = 
                 President<vector<string>>::GetInstance();				
	//President& onlyPresident = onlyPresident.GetInstance(); 
	onlyPresident.SetName("Abe Lincoln");

	cout << President<vector<string>>::GetInstance().GetName() << endl;
	cout << onlyPresident.GetName() << endl; 
	cout << onlyPresident.GetInstance().GetName() << endl; 
}

#pragma once
///#pragma warning (disable : XXXXX)
#include <string>
using namespace std;

template<typename T>
class President
{
	President() {}; //private default constructor
	President(const President&); //private copy constructor
	const President& operator = (const President&) = delete; // assignment operator

	string name;
	T containerFormerPresidents;

public:
	static President<T>& GetInstance();

	const string GetName() const;

	void SetName(string inputName);

};

#include "President.h"

template<typename T>
President<T>& President<T>::GetInstance()
{
	//static ensures only happens once 	
	static President<T> onlyInstance;
	//static President<vector<string>> onlyInstance;
	return onlyInstance;
}

template<typename T>
const string President<T>::GetName() const
{
	return name;
}

template<typename T>
void President<T>::SetName(string inputName)
{
	name = inputName;
}