Выравнивание текста по правому краю (вставка пробелов)

#include <stdio.h>
#include <string.h>
 
#define MAXSIZE 256
 
int main()
{
    char str[MAXSIZE], str1[MAXSIZE];
    int i,k=0;
    printf("Vvedite stroku: ");
    gets(str);
    for(i=0; i<strlen(str); i++)
    {
        if(str[i]=='a')
        {
            str1[k] = 'a';
            str1[k + 1]=' ';
            ++k;
        }
        else
            str1[k]=str[i];
           
 
           k++;
    }
    printf("\n");
    puts(str1);
    return 0;
}

#include <iomanip>
#include <iostream>
#include <string>
 
void printright(const std::string & str)
{
    const size_t console_max_len = 40;
    std::cout << std::setw(console_max_len) << str;
}
 
int main()
{
    printright("Your text:");
    std::string str;
    std::getline(std::cin, str);
    printright(str);
    std::cout << std::endl;
    system("pause");
}

#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
 
using namespace std;
 
int main()
{
    setlocale(LC_ALL, "rus");
    vector<string> v;
    string sm;
    while (getline(cin, sm))
    {
        
            if (sm == "")//выход по пустой строке
                break;
            v.push_back(sm);
        
    }
    int *p=new int [v.size()]; // Количество пробелов в строке
    int max = 0;
    for (int i = 0; i<(int)v.size(); i++)
    {
        p[i] = 0;
        string s;
        for (int j = 0; j<(int)v[i].length(); j++)
        {
            if (v[i][j] != ' ')
            {
                s += v[i][j];
            }
            else if (v[i][j + 1] != ' ')
            {
                s += ' ';
                p[i]++;
            }
        }
        if (s[0] == ' ')
        {
            s.erase(0, 1);
            p[i]--;
        }
        if (s[s.length() - 1] == ' ')// Если в конце пробел, то число пробелов все равно нужно уменьшить, так как он не будет участвовать в выравнивании по ширине
        {
            if (strchr(",.!-?:"\'", s[s.length() - 2]) != NULL) s.erase(s.length() - 1, 1); // И если в конце стоит знак препинания, то пробел в конце не нужен
            p[i]--;
        }
        v[i] = s;   // Заменяем неотформатированный вариант отформатированным
 
        if (max < (int)v[i].length())
        {
            max = (int)v[i].length();
        }
    }
    for (int i = 0; i<(int)v.size(); i++)   // Затем второй проход строк 
    {
        int k = (int)v[i].length();  // Резервируем длину строки, так как она сейчас будет изменяться, а нам нужно при вычислениях учитывать исходные данные
        for (int j = 0; j<(int)v[i].length(); j++)
        {
            if (v[i][j] == ' ' && j + 1 != (int)v[i].length())
            {
                v[i].insert(j, (max - k) / p[i], ' ');   // Вставляем нужное количество пробелов между строк (так чтобы их было равное количество)
                j += (max - k) / p[i];  // Смещаем указатель проходящий все символы в строке
            }
        }
        v[i].insert(0, (max - k) % p[i], ' ');  // Оставшиеся пробелы вставляем в начало чтобы выровнять строку по правому краю
    }
    for (int i = 0; i<(int)v.size(); i++)
    {
        cout << v[i] << endl;
    }
    system("pause");
    return 0;

///----------------------------------------------------------------------------|
/// C++17
/// Выравнивание текста по заданной ширине.
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
 
extern const char*          test1;
extern const char*          test2;
///------------------------------|
/// Конфиг.                      |
///------------------------------:
           size_t  WIDE   =    40;
       const char* test   = test2;
const std::string  BORD_R = "|"  ;
const std::string  BORD_L = "  |";
///------------------------------.
 
#define  l(v)  std::cout << #v << " = " << v << "\n\n";
 
typedef std::string                       S;
typedef std::vector<std::vector<S>> cargo_t;
 
S formate(std::string_view text)
{
    S       result;
    cargo_t cargo(1, std::vector<S>());
 
    auto insert_space  = [&cargo](const size_t NIL, size_t nib)
    {         auto& vs = cargo.back();
        const auto END = std::prev(vs.end());
 
        auto i = vs.begin();
        while(     nib-- ) *i++ += S(NIL+1,  ' ');
        while(i != END   ) *i++ += S(NIL  ,  ' ');
    };
 
    const S punc(" \n");
    size_t  w = 0;
 
    for(size_t i, e = 0;
            (i = text.find_first_not_of(punc, e)) != S::npos;)
    {   if( (e = text.find_first_of    (punc, i)) == S::npos )
             e = text.size();
 
        S s(text.substr(i, e - i));
 
        const size_t AS  = cargo.back().size()    ;
        const size_t AD  = cargo.back().size() - 1;
        if((w + s.size() + AS) > WIDE)
        {
            if(AS > 1)
            {   const std::div_t D = std::div(int(WIDE - w - AD), AD);
                insert_space(D.quot + 1, D.rem);
            }
 
            cargo.push_back(std::vector<S>(1, s));
            w = s.size();
        }
        else
        {   cargo .back().emplace_back(s);
            w += s.size();
        }
    }
 
    insert_space(1, 0);
 
    for(const auto& vs : cargo)
    {   w = 0;
        result += BORD_L;
        for(const auto& s : vs)
        {   result += s;
            w      += s.size();
        }
        if(WIDE >= w) result += S(WIDE - w, ' ') +  BORD_R + "\n";
        else          result += "\n";
    }
 
    return result;
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
    const char* LN = "0_______10|_______20|_______30|_______40|_______50|_\n\n";
 
    l(WIDE)
    std::cout << BORD_L << LN << formate(test) << '\n';
 
      WIDE = 30;
    l(WIDE)
    std::cout << BORD_L << LN << formate(test);
 
    std::cin.get();
}
 
///----------------------------------------------------------------------------|
/// Тестовые строки.
///----------------------------------------------------------------------------:
const char* test1 = "12 345 5577 xxxyyyzz";
const char* test2 =
R"(Вот такое задание: Выравнивание правого края. Многие современные
   текстовые редакторы предоставляют пользователю возможность форматирования
   текст, когда правый край отпечатанного
текста выравнивается за счет увеличения промежутков между словами,
встречающимися в строке.
Предлагается задача выбора подходящих промежутков. За счет изменения групп
пробелов внутри строки надо добиться того, чтобы строка имела заданную длину,
а пробелы в конце строки отсутствовали.
Напишите программу, которая в данном тексте, состоящем из нескольких строк,
производила бы выравнивание правого края до заданной ширины.
 
Вроде всё сделал, вроде запускается, но результат выводит какой то белибердой.
Помогите решить проблему с кодом, пожалуйста.)";

///----------------------------------------------------------------------------|
/// Тестовые строки.
///----------------------------------------------------------------------------:
WIDE = 30;
const char* test1 = "очень_длинное_слово_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";