Rearranging the string, C++ (vc++)

Language: Layout:

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <assert.h>

typedef std::vector<std::string>::size_type size_t_t;

size_t_t effectiveFind(std::string val, const std::vector<std::string> &v1, const std::vector<std::string> &v2)
{
	for(std::vector<std::string>::size_type i = 0; i < v1.size(); i++)
	{
		if(v1[i] != v2[i])
		{
			if(v2[i] == val) return static_cast<size_t_t>(i);
		}
	}

assert(NULL); return 0;
}

std::string addSpace(std::string val) {return (val += ' ');}

struct groupRecord
{
	groupRecord(size_t_t _pos, std::string _val) : pos(_pos), val(_val) {}

size_t_t pos;
	std::string val;
};

void insertProperPosition(std::vector<groupRecord> &target, std::string result, size_t_t position)
{
	std::vector<groupRecord>::iterator it;
	for(it = target.begin(); it != target.end() && it->pos < position; it++);

if(it == target.end()) target.push_back(groupRecord(position, result));
	else target.insert(it, groupRecord(position, result));
}

std::string rearrange(std::string a, std::string b, size_t_t &numMoves, size_t_t &numGroups)
{
	std::string val;
	size_t_t position;
	numMoves = 0;
	numGroups = 0;

std::vector<std::string> v1;
	std::vector<std::string> v2;

std::istringstream iss1(a);
	std::istringstream iss2(b);

while(iss1 >> val) v1.push_back(val);
	while(iss2 >> val) v2.push_back(val);

assert(v1.size() && v2.size());
	assert(v1.size() == v2.size());

std::vector<std::string>::size_type i;
	for(i = 0; i < v1.size(); i++)
	{
		assert(std::count(v1.begin(), v1.end(), v1[i]) == std::count(v2.begin(), v2.end(), v1[i]));
		assert(std::count(v1.begin(), v1.end(), v2[i]) == std::count(v2.begin(), v2.end(), v2[i]));
	}
	
	std::vector<groupRecord> v1_a;
	std::vector<groupRecord> v2_a;

std::vector<std::string> v1_b;
	std::vector<std::string> v2_b;

if(std::equal(v1.begin(), v1.end(), v2.begin()))
	{
		numGroups = 1;
		numMoves = 0;

std::transform(v2.begin(), v2.end() - 1, v2.begin(), addSpace);
		return std::accumulate(v2.begin(), v2.end(), std::string());
	}

size_t_t group_size, j, k;
	for(group_size = v1.size() - 1; group_size >= 2; group_size--)
	{
		for(i = 0; i <= v1.size() - group_size; i++)
		{
			if(!v1[i].empty())
			{
				for(j = 0; j <= v2.size() - group_size; j++)
				{
					if(!v2[j].empty())
					{
						if(std::equal(v1.begin() + i, v1.begin() + i + group_size, v2.begin() + j))
						{

std::transform(v1.begin() + i, v1.begin() + i + group_size - 1, v1.begin() + i, addSpace);
							std::transform(v2.begin() + j, v2.begin() + j + group_size - 1, v2.begin() + j, addSpace);

insertProperPosition(v1_a, std::accumulate(v1.begin() + i, v1.begin() + i + group_size, std::string()), i);
							insertProperPosition(v2_a, std::accumulate(v2.begin() + j, v2.begin() + j + group_size, std::string()), j);

std::fill(v1.begin() + i, v1.begin() + i + group_size, std::string());
							std::fill(v2.begin() + j, v2.begin() + j + group_size, std::string());
							
							numGroups++;
						}
					}
				}
			}
		}
	}

for(i = 0; i < v1.size(); i++)
	{
		if(!v1[i].empty())
		{
			insertProperPosition(v1_a, v1[i], i);
		}

if(!v2[i].empty())
		{
			insertProperPosition(v2_a, v2[i], i);
		}
	}

std::cout << std::endl;

for(i = 0; i < v1_a.size(); i++)
	{
		std::cout << v1_a[i].val << " ## ";
	}
	std::cout << std::endl;

for(i = 0; i < v2_a.size(); i++)
	{
		std::cout << v2_a[i].val << " ## ";
	}
	std::cout << std::endl;

numGroups += v1.size() - std::count(v1.begin(), v1.end(), std::string());

assert(v1_a.size() && v2_a.size());
	assert(v1_a.size() == v2_a.size());

for(i = 0; i < v1_a.size(); i++)
	{
		v1_b.push_back(v1_a[i].val); 
		v2_b.push_back(v2_a[i].val); 
	}

for(i = 0; i < v1_b.size(); i++) 
	{
		if(v1_b[i] != v2_b[i])
		{
			position = effectiveFind(v1_b[i], v1_b, v2_b);
			std::swap(v2_b[i], v2_b[position]); 
			numMoves++;
		}
	}

std::transform(v2_b.begin(), v2_b.end() - 1, v2_b.begin(), addSpace);

return std::accumulate(v2_b.begin(), v2_b.end(), std::string());

}

int main()
{
	size_t_t numMoves;
	size_t_t numGroups;

// Emptying these strings mean you have to input them manually
	std::string line1 = "3 2 1 4 5"; // "3 2 1 4 5"
	std::string line2 = "2 3 1 4 5"; // "2 3 1 4 5"

std::cout << "Enter two strings : " << std::endl;

if(!line1.size() || !line2.size())
	{
		std::getline(std::cin, line1);
		std::getline(std::cin, line2);
	}
	else
	{
		std::cout << line1 << std::endl;
		std::cout << line2 << std::endl;
	}

line2 = rearrange(line1, line2, numMoves, numGroups);

std::cout << std::endl;
	std::cout << line1 << std::endl;
	std::cout << line2 << std::endl;
	std::cout << numGroups << ' ' << numMoves << std::endl;

return 0;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input