Павел Язовских

Включаю режим экстрасенса. Потому что std::to_string появился в C++11, а у вас в Code::Blocks используется gcc без -std=c++11. Но лучше напишите, какие у вас сообщения об ошибках.

iamevg, это не ответ на вопрос насчёт именно "как выйти из десятка вложенных циклов", это просто другое решение вашей задачи, в котором этого не требуется. Делений больше, сравнений меньше:

std::vector<std::vector<int>> matrix = {{1,2,3,42},{5,6,7,8},{9,10,11,42}};
    const size_t limit = matrix.size() * matrix.front().size();
    const size_t cols = matrix.front().size();
    size_t i = 0;
    size_t j = 1;
    while(i < limit - 1 && matrix[i / cols][i % cols] != matrix[j / cols][j % cols])
    {
        if(++j == limit) j = ++i + 1;
    }
    if(i < limit - 1)
    {
        std::cout << "Indices of elements: [" << i / cols << "," << i % cols << "]";
        std::cout << "[" << j / cols << "," << j % cols << "]" << std::endl;
    }
    else std::cout << "Not found" << std::endl;

Было же недавно что-то такое на Хабре. Цикл от 100 до 0 с выводом значений но без условных операторов. В комментариях там несколько вариантов было. Мне больше всего понравилась реализация с выделением через размещающий new[] и статическую переменную в классе в этом комментарии.

Крайне рекомендую "Мейерс С. - Эффективный и современный C++. 42 рекомендации по использованию C++11 и C++14". Не по 17-му стандрарту, но умные указатели и не в нём появились.

Попробуйте в голове прикинуть, сколько раз у вас выполнится цикл, если взять n=2.

Нет, нельзя. У вас цикл до n, значение которого заранее неизвестно. Либо вы неправильно задаёте вопрос.

Итого, из остальных двух ответов:
1) пользоваться типом long long (или unsigned long long, если заранее известно, что числа положительные)
2) пробежаться по всем числам от 1 до n, запомнить все простые в список
3) найти все сочетания по 2 с повторами из списка, дающие при умножении n

Не знаю насчёт topcoder, но в codewars, например, чужие решения закрыты до момента, пока вы сами не решите задачу.

for (int i = A; A <= B; i++)
{
sum = sum + i;
cout << "Сума чисел от а до b = " << sum << endl;
}

В условии выхода из цикла ошибка. Должно быть i <= B. Ещё, на всякий случай, sum лучше сделать типа long long.

Раз вопрос в теме про C++, то вас, наверное, не интересуют raw-массивы и raw-loops. Тогда можно так:

#include <algorithm>
std::vector<std::vector<int>> arr = {{0,1,2,3},{0,1,2,3},{0,1,2,3}};
std::for_each(arr.begin(), arr.end(), [](auto& row){ std::reverse(row.begin(), row.end()); });

Проверьте возвращённый статус при открытии файла в "hello". Если пользуетесь fopen - посмотрите www.cplusplus.com/reference/cerrno/errno

Не оптимальное, но работающее решение, которое вам уже предлагали, основанное на преобразовании в формат YYYYMMDD:

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

int main(void)
{
	std::vector<std::string> array_data{ "13.11.1999", "09.10.1997", "22.05.1995" };
	auto as_yyyymmdd = [](const std::string& src){
		return src.substr(6,4) + src.substr(3,2) + src.substr(0,2); 
	};
	auto min_date_it = std::min_element(array_data.begin(), array_data.end(),
		[as_yyyymmdd](const std::string& a, const std::string& b){ 
			return as_yyyymmdd(a) < as_yyyymmdd(b);
		});
	std::string min_date = *min_date_it;
	std::cout << min_date << std::endl;
	return 0;
}

Если компилятор позволяет, можно использовать itoa, если нет - sprintf. Не C++, но будет работать.

std::string hexString = "0xBAADF00D";
char octString[MAX_BUF];
itoa(std::stoi(hexString, 0, 16 ), octString, 8);

Придумался мне тут интересный велосипед. Так как шестнадцатеричная и восьмеричная системы счисления основаны на степени двойки, это сильно облегчает нам жизнь (схема тут). 12 двоичных разрядов могут быть записаны как три шестнадцатеричные цифры, либо как четыре восьмеричные. Таким образом, для преобразования шестнадцатеричной строки в восьмеричную, нужно все тройки шестнадцатеричных символов (с конца, начало дополнить нулями) заменить соответствующими четвёрками восьмеричных:

#include <cstring>
#include <iostream>

unsigned getHexDigit(char hexChar)
{
	if (hexChar >= '0' && hexChar <= '9')
	{
		return hexChar - '0';
	}
	if (hexChar >= 'A' && hexChar <= 'F')
	{
		return 10 + hexChar - 'A';
	}	
	if (hexChar >= 'a' && hexChar <= 'f')
	{
		return 10 + hexChar - 'a';
	}
	return 0;
}

void getOctQuartet(const char* hex, char* oct)
{
	unsigned number = getHexDigit(hex[0]) << 8 | getHexDigit(hex[1]) << 4 | getHexDigit(hex[2]);
	oct[0] = '0' + (number >> 9 & 07);
	oct[1] = '0' + (number >> 6 & 07);
	oct[2] = '0' + (number >> 3 & 07);
	oct[3] = '0' + (number & 07);
}

char* getOctString(const char* hexString)
{
	const size_t hexStrLen = strlen(hexString);
	const size_t prefixLen = hexStrLen % 3;
	char* octString = new char[(hexStrLen - prefixLen + 3) / 3 * 4 + 1];	
	char* pOct = octString;
	if (prefixLen > 0)
	{
		char hexPrefix[3] = { '0'
			, prefixLen == 2 ? hexString[0] : '0'
			, prefixLen == 2 ? hexString[1] : hexString[0] 
		};
		getOctQuartet(hexPrefix, octString);
		pOct += 4;
	}

	const char* pHex = hexString + prefixLen;
	while(pHex < hexString + hexStrLen)
	{
		getOctQuartet(pHex, pOct);
		pHex += 3;
		pOct += 4;
	}
	*pOct = '\0';

	return octString;
}

int main()
{
	char hexString[] = "123456789ABCDEF";
	char* octString = getOctString(hexString);
	std::cout << octString << std::endl;
	delete[] octString;
	return 0;
}

Ваш оператор = очень жестоко обходится с правой частью. Написав a=b; я бы очень удивился, обнаружив в b содержимое a.